devlensio 1.0.0 → 1.0.2

package/dist/extractors/index.js

@@ -11,6 +11,83 @@ export function defaultParseResult(stdout) {
 }
 // Subprocess Extractor Registry
 // These extractors are spawned as child processes.
+// ── extractor artifact resolution ────────────────────────────────────────────
+// The subprocess extractors (python venv, java jar, go/rust static binaries)
+// are DATA files inside the devlensio package. In a normal install they sit at
+// `<pkg>/extractors/…` and resolve relative to this module. But when devlensio
+// is BUNDLED into a standalone binary (`bun build --compile`, which is how the
+// `@devlensio/cli` and MCP server ship), `import.meta.url` points at the binary
+// itself, so the URL-relative path resolves to `/extractors/…` (nonexistent).
+// The fallbacks below find the real extractor root for that case.
+function resolveExtractorsRoot() {
+    // 1. Env override (CI / unusual layouts): DEVLENS_EXTRACTORS_DIR = the
+    //    `extractors/` directory itself.
+    const env = process.env.DEVLENS_EXTRACTORS_DIR;
+    if (env) {
+        const candidate = path.resolve(env);
+        if (fs.existsSync(path.join(candidate, "python")) && fs.existsSync(path.join(candidate, "java"))) {
+            return candidate;
+        }
+    }
+    // 2. Normal install: `<pkg>/dist/extractors/../../extractors` = `<pkg>/extractors`.
+    const viaModule = fileURLToPath(new URL("../../extractors", import.meta.url));
+    if (fs.existsSync(viaModule))
+        return viaModule;
+    // 3. Bundled binary: walk up from this bundle's own directory AND from the
+    //    cwd to find `<…>/node_modules/devlensio/extractors`. Covers running the
+    //    compiled CLI inside a project that depends on devlensio, and global
+    //    installs where devlensio sits hoisted beside the CLI package.
+    const scanRoots = [
+        fileURLToPath(new URL(".", import.meta.url)),
+        process.cwd(),
+    ];
+    for (const start of scanRoots) {
+        let dir = path.resolve(start);
+        for (;;) {
+            const candidate = path.join(dir, "node_modules", "devlensio", "extractors");
+            if (fs.existsSync(candidate))
+                return candidate;
+            const parent = path.dirname(dir);
+            if (parent === dir)
+                break;
+            dir = parent;
+        }
+    }
+    return null;
+}
+const extractorsRoot = resolveExtractorsRoot();
+/** Absolute path to an extractor artifact under the resolved root (or null). */
+function extractorArtifact(rel) {
+    return extractorsRoot ? path.join(extractorsRoot, rel) : null;
+}
+function resolvePythonCommand() {
+    const venvBin = process.platform === "win32" ? "Scripts/python.exe" : "bin/python";
+    const venvPython = extractorArtifact(`python/.venv/${venvBin}`) ??
+        // Last resort: URL-relative (pre-fix behavior for direct-from-dist runs).
+        fileURLToPath(new URL(`../../extractors/python/.venv/${venvBin}`, import.meta.url));
+    return fs.existsSync(venvPython) ? venvPython : "python3";
+}
+function platformDir() {
+    return process.platform === "win32"
+        ? "windows-amd64"
+        : process.platform === "darwin"
+            ? `darwin-${process.arch === "arm64" ? "arm64" : "amd64"}`
+            : `linux-${process.arch === "arm64" ? "arm64" : "amd64"}`;
+}
+function resolveJavaJarPath() {
+    const rel = "java/devlens_java_extractor.jar";
+    return extractorArtifact(rel) ?? fileURLToPath(new URL(`../../extractors/${rel}`, import.meta.url));
+}
+function resolveGoBinaryPath() {
+    const exe = process.platform === "win32" ? ".exe" : "";
+    const rel = `go/bin/${platformDir()}/devlens_go_extractor${exe}`;
+    return extractorArtifact(rel) ?? fileURLToPath(new URL(`../../extractors/${rel}`, import.meta.url));
+}
+function resolveRustBinaryPath() {
+    const exe = process.platform === "win32" ? ".exe" : "";
+    const rel = `rust/bin/${platformDir()}/devlens_rust_extractor${exe}`;
+    return extractorArtifact(rel) ?? fileURLToPath(new URL(`../../extractors/${rel}`, import.meta.url));
+}
 const SUBPROCESS_EXTRACTORS = {
     python: {
         language: "python",
@@ -26,7 +103,7 @@ const SUBPROCESS_EXTRACTORS = {
         // Absolute path — the runner spawns with cwd=repoPath, so a bare jar
         // name would be looked up inside the analyzed repo. fileURLToPath
         // also decodes percent-escapes (spaces in the path).
-        args: ["-jar", fileURLToPath(new URL("../../extractors/java/devlens_java_extractor.jar", import.meta.url))],
+        args: ["-jar", resolveJavaJarPath()],
         parseResult: defaultParseResult,
     },
     go: {
@@ -52,44 +129,6 @@ const SUBPROCESS_EXTRACTORS = {
 export function getExtractor(language) {
     return SUBPROCESS_EXTRACTORS[language];
 }
-// The python extractor is a pip package installed into a venv that the
-// postinstall script creates (extractors/python/setup.mjs). Resolve that
-// venv's interpreter absolutely — same pattern as the java jar path —
-// because the runner spawns with cwd=repoPath. Platform-aware: Windows
-// venvs put the interpreter at Scripts\python.exe, Unix at bin/python.
-function resolvePythonCommand() {
-    const venvBin = process.platform === "win32" ? "Scripts/python.exe" : "bin/python";
-    const venvPython = fileURLToPath(new URL(`../../extractors/python/.venv/${venvBin}`, import.meta.url));
-    return fs.existsSync(venvPython) ? venvPython : "python3";
-}
-// The Go extractor ships as a static binary per platform, cross-compiled at
-// publish time (prepack → extractors/go/build.mjs). Resolve the CURRENT
-// platform's binary absolutely — same reason as the java jar path (the runner
-// spawns with cwd=repoPath). fileURLToPath also decodes percent-escapes
-// (spaces in the path).
-function resolveGoBinaryPath() {
-    const platformDir = process.platform === "win32"
-        ? "windows-amd64"
-        : process.platform === "darwin"
-            ? `darwin-${process.arch === "arm64" ? "arm64" : "amd64"}`
-            : `linux-${process.arch === "arm64" ? "arm64" : "amd64"}`;
-    const exe = process.platform === "win32" ? ".exe" : "";
-    return fileURLToPath(new URL(`../../extractors/go/bin/${platformDir}/devlens_go_extractor${exe}`, import.meta.url));
-}
-// The Rust extractor ships as a static binary per platform, cross-compiled at
-// publish time (prepack → extractors/rust/build.mjs). Resolve the CURRENT
-// platform's binary absolutely — same reason as the go binary path (the runner
-// spawns with cwd=repoPath). fileURLToPath also decodes percent-escapes
-// (spaces in the path).
-function resolveRustBinaryPath() {
-    const platformDir = process.platform === "win32"
-        ? "windows-amd64"
-        : process.platform === "darwin"
-            ? `darwin-${process.arch === "arm64" ? "arm64" : "amd64"}`
-            : `linux-${process.arch === "arm64" ? "arm64" : "amd64"}`;
-    const exe = process.platform === "win32" ? ".exe" : "";
-    return fileURLToPath(new URL(`../../extractors/rust/bin/${platformDir}/devlens_rust_extractor${exe}`, import.meta.url));
-}
 // langauges handled inline meaning JS/TS
 export const INLINE_LANGUAGES = new Set(["javascript", "typescript"]);
 // Does `command` resolve? Absolute path → existsSync; bare name → PATH scan

package/extractors/rust/src/calls.rs

@@ -41,7 +41,7 @@ pub fn detect_calls(
     let mut edges = vec![];
 
     for pf in &repo.files {
-        if pf.is_test_file {
+        if pf.is_pure_test_file {
             continue;
         }
         for item in &pf.items {

package/extractors/rust/src/enrich.rs

@@ -57,7 +57,7 @@ pub fn enrich_nodes(
     let mut model_table: std::collections::HashMap<String, String> =
         std::collections::HashMap::new();
     for pf in &repo.files {
-        if pf.is_test_file {
+        if pf.is_pure_test_file {
             continue;
         }
         for item in &pf.items {

package/extractors/rust/src/imports.rs

@@ -34,7 +34,7 @@ pub fn detect_imports(
     let mut seen: std::collections::HashSet<(String, String)> = std::collections::HashSet::new();
 
     for pf in &repo.files {
-        if pf.is_test_file {
+        if pf.is_pure_test_file {
             // test files ARE leaf nodes, but they still import — emit edges
             // from the TEST node (same file id — parentFile covers it)
         }

package/extractors/rust/src/inheritance.rs

@@ -37,7 +37,7 @@ pub fn detect_inheritance(
     let mut edges = vec![];
     let mut nodes = vec![];
     for pf in &repo.files {
-        if pf.is_test_file {
+        if pf.is_pure_test_file {
             continue;
         }
         for item in &pf.items {

package/extractors/rust/src/nodes.rs

@@ -2,9 +2,11 @@
 //
 // Contract rules enforced here:
 //   - FILE id `file::rel/path.rs`; file nodes parent themselves
-//   - TEST files (any #[test] fn) = LEAF nodes: nodes=[] for them, test fns
-//     ride in metadata.testCases only (the bug that shipped in Python's
-//     parser — asserted in the bun suite)
+//   - PURE test files (tests/ integration files, or files whose every item is
+//     a #[test] fn) = LEAF TEST nodes; Rust's idiomatic inline #[cfg(test)]
+//     mod tests must NOT collapse a mixed production file — its non-test items
+//     emit normally and #[test] fns emit as FUNCTION nodes flagged
+//     metadata.isTestFunction (test bodies stay out of prod call edges there)
 //   - rawCode + codeHash on every FUNCTION/METHOD/STRUCT/ENUM/TRAIT/IMPL_BLOCK
 //   - deterministic ids (file-scoped; trait-impl method suffix for the
 //     same-name-different-trait collision class)
@@ -17,7 +19,7 @@ use serde_json::{Map, Value};
 pub fn collect_file_nodes(files: &[ParsedFile]) -> Vec<CodeNode> {
     let mut out = vec![];
     for pf in files {
-        if pf.is_test_file {
+        if pf.is_pure_test_file {
             let mut n = file_node(&pf.rel_path, pf.line_count, NODE_TEST);
             let meta = n
                 .metadata
@@ -30,25 +32,43 @@ pub fn collect_file_nodes(files: &[ParsedFile]) -> Vec<CodeNode> {
             }
             out.push(n);
         } else {
-            out.push(file_node(&pf.rel_path, pf.line_count, NODE_FILE));
+            let mut n = file_node(&pf.rel_path, pf.line_count, NODE_FILE);
+            // Mixed files keep a testCases index so consumers that never walk
+            // FUNCTION nodes still see the file's tests.
+            if !pf.test_fns.is_empty() {
+                let meta = n
+                    .metadata
+                    .entry("testCases".to_string())
+                    .or_insert_with(|| Value::Array(vec![]));
+                if let Value::Array(arr) = meta {
+                    for t in &pf.test_fns {
+                        arr.push(Value::from(t.clone()));
+                    }
+                }
+            }
+            out.push(n);
         }
     }
     out
 }
 
-/// Code nodes (FUNCTION/METHOD/STRUCT/ENUM/TRAIT/IMPL_BLOCK) — test fns are
-/// NOT emitted (leaf rule); they feed metadata.testCases only.
+/// Code nodes. PURE test files stay leaves (their fns ride in testCases).
+/// Mixed files emit ALL items; #[test] fns are flagged metadata.isTestFunction
+/// instead of being dropped, so a test function is addressable without a new
+/// node type.
 pub fn collect_code_nodes(files: &[ParsedFile]) -> Vec<CodeNode> {
     let mut out = vec![];
     for pf in files {
-        if pf.is_test_file {
+        if pf.is_pure_test_file {
             continue;
         }
         for item in &pf.items {
+            let mut n = item_node(pf, item);
             if item.is_test {
-                continue;
+                n.metadata
+                    .insert("isTestFunction".to_string(), Value::from(true));
             }
-            out.push(item_node(pf, item));
+            out.push(n);
         }
     }
     out

package/extractors/rust/src/orm_edges.rs

@@ -21,7 +21,7 @@ use std::collections::HashMap;
 pub fn table_to_model_map(repo: &ParsedRepo) -> HashMap<String, String> {
     let mut map = HashMap::new();
     for pf in &repo.files {
-        if pf.is_test_file {
+        if pf.is_pure_test_file {
             continue;
         }
         for item in &pf.items {
@@ -89,7 +89,7 @@ pub fn detect_orm_edges(
     let table_to_schema_file = table_to_schema_file_map(repo);
 
     for pf in &repo.files {
-        if pf.is_test_file {
+        if pf.is_pure_test_file {
             continue;
         }
         for item in &pf.items {

package/extractors/rust/src/parser.rs

@@ -162,7 +162,12 @@ pub struct ParsedFile {
     pub items: Vec<ParsedItem>,
     pub tables: Vec<TableDecl>,
     pub test_fns: Vec<String>,
-    pub is_test_file: bool,
+    /// True only when the file is EXCLUSIVELY tests (every top-level item is a
+    /// #[test] fn, or the file only holds inline #[cfg(test)] mods). Rust's
+    /// idiomatic inline `#[cfg(test)] mod tests` must NOT collapse a mixed
+    /// production file into a TEST leaf — only pure test files get leaf
+    /// treatment (mirrors the intent of go's _test.go rule).
+    pub is_pure_test_file: bool,
     pub line_count: i64,
 }
 
@@ -326,7 +331,7 @@ pub fn parse_file(rel_path: &str, source: &str) -> Result<ParsedFile, String> {
         items: vec![],
         tables: vec![],
         test_fns: vec![],
-        is_test_file: false,
+        is_pure_test_file: false,
         line_count: line_index.line_count() as i64,
     };
 
@@ -342,7 +347,7 @@ pub fn parse_file(rel_path: &str, source: &str) -> Result<ParsedFile, String> {
     }
     pf.ast.items = ast_items;
 
-    pf.is_test_file = !pf.test_fns.is_empty();
+    pf.is_pure_test_file = !pf.test_fns.is_empty() && pf.items.iter().all(|i| i.is_test);
     Ok(pf)
 }
 

package/extractors/rust/src/routes.rs

@@ -96,7 +96,7 @@ pub fn detect_routes(
     let mut func_lit_vars: HashMap<(String, String), String> = HashMap::new();
 
     for pf in &repo.files {
-        if pf.is_test_file {
+        if pf.is_pure_test_file {
             continue;
         }
         for item in &pf.items {
@@ -195,7 +195,7 @@ pub fn detect_routes(
     // ── actix-web / rocket: attribute macros ──
     if framework == "actix-web" || framework == "rocket" {
         for pf in &repo.files {
-            if pf.is_test_file {
+            if pf.is_pure_test_file {
                 continue;
             }
             for item in &pf.items {

package/extractors/rust/src/tests.rs

@@ -22,7 +22,7 @@ pub fn detect_tests(
 ) -> Vec<CodeEdge> {
     let mut edges = vec![];
     for pf in &repo.files {
-        if !pf.is_test_file {
+        if !pf.is_pure_test_file {
             continue;
         }
         let from = format!("file::{}", pf.rel_path);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "devlensio",
-  "version": "1.0.0",
+  "version": "1.0.2",
   "description": "Codebase intelligence engine for TypeScript/JavaScript/React/Next.js, Python, Java, Go, and Rust repositories.",
   "type": "module",
   "main": "./dist/index.js",