devlensio 0.6.2 → 1.0.0

package/extractors/rust/src/tests.rs

@@ -0,0 +1,109 @@
+// tests.rs — TESTS edges from TEST leaf nodes to production symbols.
+//
+// Rust test naming (documented cargo convention): `fn test_foo` / `fn foo_test`
+// inside #[cfg(test)] mods or `tests/` integration files. Resolution ladder:
+//   1. same-file name-match (`test_helper` → `helper` in the same file)
+//   2. the file's use symbol maps (integration tests `use crate::foo::bar` →
+//      src symbol — the playbook's symbol-map refinement)
+//   3. crate-wide name-match (closest_by_path)
+// Sub-tests (t.Run equivalents — #[test] with nested logic) ride in
+// metadata.testCases only (V1).
+
+use crate::contract::{edge, CodeEdge};
+use crate::extractor::{Options, ParsedRepo};
+use crate::lookup::LookupMaps;
+use crate::module_map::ModuleMap;
+
+pub fn detect_tests(
+    repo: &ParsedRepo,
+    module_map: &ModuleMap,
+    lookup: &LookupMaps,
+    _opts: &Options,
+) -> Vec<CodeEdge> {
+    let mut edges = vec![];
+    for pf in &repo.files {
+        if !pf.is_test_file {
+            continue;
+        }
+        let from = format!("file::{}", pf.rel_path);
+        let base_module = crate::walker::module_path_for_file(&pf.rel_path);
+        for name in &pf.test_fns {
+            // 1. same-file name-match: test_helper → helper; helper_test → helper
+            let candidate = strip_test_affix(name);
+            if let Some(target) = same_file_symbol(&pf.rel_path, &candidate, lookup) {
+                edges.push(edge(&from, &target, "TESTS"));
+                continue;
+            }
+            // 2. use symbol maps: `use crate::models::user::User;` → user.rs
+            if let Some(target) = use_map_symbol(pf, &candidate, &base_module, module_map, lookup) {
+                edges.push(edge(&from, &target, "TESTS"));
+                continue;
+            }
+            // 3. crate-wide name-match
+            if let Some(target) = lookup.closest_by_path(&candidate, &pf.rel_path) {
+                edges.push(edge(&from, &target, "TESTS"));
+            }
+        }
+    }
+    edges
+}
+
+fn strip_test_affix(name: &str) -> String {
+    if let Some(rest) = name.strip_prefix("test_") {
+        return rest.to_string();
+    }
+    if let Some(rest) = name.strip_suffix("_test") {
+        return rest.to_string();
+    }
+    name.to_string()
+}
+
+fn same_file_symbol(rel: &str, name: &str, lookup: &LookupMaps) -> Option<String> {
+    let ids = lookup.nodes_by_name.get(name)?;
+    ids.iter()
+        .find(|id| id.starts_with(&format!("{}::", rel)))
+        .cloned()
+}
+
+fn use_map_symbol(
+    pf: &crate::parser::ParsedFile,
+    name: &str,
+    base_module: &str,
+    module_map: &ModuleMap,
+    lookup: &LookupMaps,
+) -> Option<String> {
+    // direct: `use crate::x::Name;` — alias Name → path ending in Name
+    if let Some(target) = lookup
+        .symbol_maps
+        .get(&pf.rel_path)
+        .and_then(|syms| syms.get(name))
+    {
+        if let Some((file, rest)) = module_map.resolve(target, base_module) {
+            if rest.is_empty() {
+                // the use named a module — edge to its file
+                return Some(format!("file::{}", file));
+            }
+            let file_module = crate::walker::module_path_for_file(&file);
+            let key = if file_module.is_empty() {
+                rest.clone()
+            } else {
+                format!("{}::{}", file_module, rest)
+            };
+            if let Some(id) = lookup.item_by_module_name.get(&key) {
+                return Some(id.clone());
+            }
+            return lookup.closest_by_path(&rest, &file);
+        }
+    }
+    // glob: `use crate::models::*;` — try each glob base
+    if let Some(globs) = lookup.glob_maps.get(&pf.rel_path) {
+        for g in globs {
+            if let Some((file, _)) = module_map.resolve(&format!("{}::{}", g, name), base_module) {
+                if let Some(id) = lookup.closest_by_path(name, &file) {
+                    return Some(id);
+                }
+            }
+        }
+    }
+    None
+}

package/extractors/rust/src/thirdparty.rs

@@ -0,0 +1,114 @@
+// thirdparty.rs — [crate]/name third-party registry + gating (mirrors
+// go/thirdparty.go and python/third_party.py).
+//
+// Gating rule (non-negotiable contract): options.includeThirdPartyLibs (both
+// spellings) is THE gate — absent/empty → ZERO third-party nodes. All
+// detectors (imports/calls/inheritance) share ONE registry.
+
+use crate::contract::{base_metadata, code_node, CodeNode, NODE_THIRD_PARTY};
+use crate::fingerprint::ParsedManifest;
+use std::collections::{HashMap, HashSet};
+
+/// std crates — first path segment of a use path in this set → skip tier
+/// (no node, no edge).
+pub const STD_CRATES: [&str; 3] = ["std", "core", "alloc"];
+
+pub struct ThirdPartyRegistry {
+    /// gated (allowed) crate names — empty = gate everything
+    allowed: HashSet<String>,
+    /// crate name → node (id [crate]/name)
+    crate_nodes: HashMap<String, CodeNode>,
+    /// crate name::member → node (id [crate]/name::member)
+    member_nodes: HashMap<String, CodeNode>,
+}
+
+impl ThirdPartyRegistry {
+    pub fn new(allowed: &[String]) -> Self {
+        ThirdPartyRegistry {
+            allowed: allowed.iter().cloned().collect(),
+            crate_nodes: HashMap::new(),
+            member_nodes: HashMap::new(),
+        }
+    }
+
+    /// Strict membership gate (mirrors go's `permitted`): absent/empty
+    /// `allowed` → ZERO third-party nodes (the engine controls inclusion via
+    /// options.includeThirdPartyLibs). Hyphen/underscore normalization for
+    /// Cargo crate names (dep `actix-web` ↔ crate `actix_web`).
+    pub fn gated(&self, crate_name: &str) -> bool {
+        if self.allowed.contains(crate_name) {
+            return true;
+        }
+        let underscored = crate_name.replace('-', "_");
+        self.allowed
+            .iter()
+            .any(|a| a.replace('-', "_") == underscored)
+    }
+
+    /// crate node [crate]/name — None when not gated.
+    pub fn crate_node(&mut self, crate_name: &str) -> Option<CodeNode> {
+        if !self.gated(crate_name) {
+            return None;
+        }
+        if let Some(n) = self.crate_nodes.get(crate_name) {
+            return Some(n.clone());
+        }
+        let mut meta = base_metadata();
+        meta.insert("crateName".to_string(), crate_name.into());
+        let n = code_node(
+            &crate::lookup::third_party_id(crate_name),
+            "",
+            crate_name,
+            NODE_THIRD_PARTY,
+            0,
+            0,
+            "",
+            meta,
+        );
+        self.crate_nodes.insert(crate_name.to_string(), n.clone());
+        Some(n)
+    }
+
+    /// member node [crate]/name::member (e.g. serde::Serialize) — None when
+    /// not gated.
+    pub fn member_node(&mut self, crate_name: &str, member: &str) -> Option<CodeNode> {
+        if !self.gated(crate_name) {
+            return None;
+        }
+        let key = format!("{}::{}", crate_name, member);
+        if let Some(n) = self.member_nodes.get(&key) {
+            return Some(n.clone());
+        }
+        let mut meta = base_metadata();
+        meta.insert("crateName".to_string(), crate_name.into());
+        meta.insert("member".to_string(), member.into());
+        let id = format!("{}::{}", crate::lookup::third_party_id(crate_name), member);
+        let n = code_node(&id, "", &key, NODE_THIRD_PARTY, 0, 0, "", meta);
+        self.member_nodes.insert(key, n.clone());
+        Some(n)
+    }
+
+    /// All created nodes (collected last in the pipeline — like go).
+    pub fn all_nodes(&self) -> Vec<CodeNode> {
+        let mut out: Vec<CodeNode> = self.crate_nodes.values().cloned().collect();
+        out.extend(self.member_nodes.values().cloned());
+        out
+    }
+}
+
+/// First segment of a path (e.g. "serde" from "serde::Serialize").
+pub fn first_segment(path: &str) -> &str {
+    path.split("::").next().unwrap_or(path)
+}
+
+/// True when the first segment is a std crate (skip tier).
+pub fn is_std(first: &str) -> bool {
+    STD_CRATES.contains(&first)
+}
+
+/// True when the first segment names an external crate (in the manifest's
+/// dependency set). NOT std, NOT a local module — decided by callers using
+/// the module map.
+pub fn is_external_crate(first: &str, mf: &ParsedManifest) -> bool {
+    mf.is_external_crate(first)
+}

package/extractors/rust/src/walker.rs

@@ -0,0 +1,82 @@
+// walker.rs — .rs file discovery with IGNORE pruning at the frontier
+// (mirrors go/walker.go). Deterministic: read_dir entries are sorted.
+
+use std::path::Path;
+
+const IGNORE_DIRS: [&str; 9] = [
+    ".git",
+    "node_modules",
+    "target", // cargo build dir (can be ~1GB)
+    "vendor", // vendored deps — never walked for nodes (like go)
+    "bin",
+    "dist",
+    "build",
+    ".cargo",
+    ".idea",
+];
+
+/// Recursively collect .rs files under repo_path, pruning IGNORE dirs at the
+/// frontier (never descend into them).
+pub fn collect_rs_files(repo_path: &str) -> Vec<String> {
+    let mut out = vec![];
+    walk(repo_path, repo_path, &mut out);
+    out.sort();
+    out
+}
+
+fn walk(root: &str, dir: &str, out: &mut Vec<String>) {
+    let entries = match std::fs::read_dir(dir) {
+        Ok(e) => e,
+        Err(_) => return,
+    };
+    let mut names: Vec<String> = entries
+        .flatten()
+        .map(|e| e.file_name().to_string_lossy().to_string())
+        .collect();
+    names.sort();
+    for name in names {
+        if name.starts_with('.') && name != ".github" {
+            continue;
+        }
+        let full = format!("{}/{}", dir, name);
+        let rel = full
+            .strip_prefix(root)
+            .unwrap_or(&full)
+            .trim_start_matches('/');
+        let path = Path::new(&full);
+        if path.is_dir() {
+            if IGNORE_DIRS.contains(&name.as_str()) {
+                continue;
+            }
+            walk(root, &full, out);
+        } else if name.ends_with(".rs") {
+            out.push(rel.to_string());
+        }
+    }
+}
+
+/// Derive a file's module path within its crate: strip the crate's `src`
+/// segment, drop `mod.rs`/`main.rs`/`lib.rs` suffixes, map / → ::.
+///   src/models/user.rs  → models::user
+///   src/foo/mod.rs      → foo
+///   src/main.rs         → (crate root) ""
+///   crates/a/src/bar.rs → crates::a::bar (workspace member)
+pub fn module_path_for_file(rel_path: &str) -> String {
+    let mut parts: Vec<&str> = rel_path.split('/').collect();
+    if let Some(idx) = parts.iter().position(|p| *p == "src") {
+        parts = parts[idx + 1..].to_vec();
+    }
+    let mut last = parts.pop().unwrap_or("");
+    if last == "mod.rs" || last == "main.rs" || last == "lib.rs" {
+        last = "";
+    } else {
+        last = last.strip_suffix(".rs").unwrap_or(last);
+    }
+    if last.is_empty() {
+        return parts.join("::");
+    }
+    if parts.is_empty() {
+        return last.to_string();
+    }
+    format!("{}::{}", parts.join("::"), last)
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "devlensio",
-  "version": "0.6.2",
-  "description": "Codebase intelligence engine for TypeScript/JavaScript/Reactjs/Nextjs repositories.",
+  "version": "1.0.0",
+  "description": "Codebase intelligence engine for TypeScript/JavaScript/React/Next.js, Python, Java, Go, and Rust repositories.",
   "type": "module",
   "main": "./dist/index.js",
   "module": "./dist/index.js",
@@ -17,13 +17,31 @@
     "start": "bun src/server/index.ts",
     "build": "tsc --project tsconfig.build.json",
     "test": "bun test",
-    "export-graph": "bun src/debug/exportGraph.ts"
+    "export-graph": "bun src/debug/exportGraph.ts",
+    "prepack": "node extractors/java/build.mjs && node extractors/go/build.mjs && node extractors/rust/build.mjs",
+    "postinstall": "node extractors/python/setup.mjs"
   },
   "keywords": ["codebase", "graph", "ast", "typescript", "javascript", "devtools"],
   "author": "",
   "license": "AGPL-3.0",
   "files": [
-    "dist/**/*"
+    "dist/**/*",
+    "extractors/java/**",
+    "!extractors/java/classes",
+    "!extractors/java/lib",
+    "!extractors/java/sources.txt",
+    "extractors/python/**",
+    "!extractors/python/.venv",
+    "!extractors/python/*.egg-info",
+    "!extractors/python/**/__pycache__",
+    "extractors/go/**",
+    "!extractors/go/tests",
+    "extractors/rust/**",
+    "!extractors/rust/tests",
+    "!extractors/rust/target",
+    "!extractors/rust/Cargo.lock",
+    "!extractors/python/tests",
+    "!extractors/java/tests"
   ],
   "dependencies": {
     "@anthropic-ai/sdk": "^0.104.2",