devlensio 0.2.0

package/dist/graph/edges/stateEdges.js

@@ -0,0 +1,206 @@
+const REDUX_READ_HOOKS = ["useSelector", "useSelectorShallowEqual"]; // Redux hooks that indicate reads
+const REDUX_WRITE_HOOKS = ["useDispatch"]; // Redux hooks that indicate writes
+// Recoil hooks and what they mean
+const RECOIL_READ_HOOKS = ["useRecoilValue", "useRecoilValueLoadable"];
+const RECOIL_WRITE_HOOKS = ["useSetRecoilState", "useResetRecoilState"];
+const RECOIL_BOTH_HOOKS = ["useRecoilState", "useRecoilStateLoadable"];
+// Jotai hooks and what they mean
+const JOTAI_READ_HOOKS = ["useAtomValue"];
+const JOTAI_WRITE_HOOKS = ["useSetAtom"];
+const JOTAI_BOTH_HOOKS = ["useAtom"];
+// Context hooks
+const CONTEXT_HOOKS = ["useContext"];
+// Main function to detect state edges based on hooks used in components and hooks
+export function detectStateEdges(nodes, lookupMp) {
+    const edges = [];
+    // Build a fast name → store node map from storeNodes
+    // This is separate from nodesByName because we only want
+    // to match against STATE_STORE nodes not all nodes
+    const storesByName = new Map();
+    for (const store of lookupMp.storeNodes) {
+        storesByName.set(store.name, store);
+    }
+    // Separate Redux stores for useSelector/useDispatch
+    // which don't reference a store by name directly
+    const reduxStores = lookupMp.storeNodes.filter((n) => n.metadata.storeType === "redux");
+    for (const node of nodes) {
+        // Only components and hooks use state
+        if (node.type !== "COMPONENT" && node.type !== "HOOK")
+            continue;
+        // COMPONENT nodes store hook calls in metadata.hooks; HOOK nodes use metadata.dependencies
+        const hooks = (node.type === "HOOK" ? node.metadata.dependencies : node.metadata.hooks);
+        if (!hooks || hooks.length === 0)
+            continue;
+        for (const hookName of hooks) {
+            // ─── Zustand ──────────────────────────────────────────────────────────
+            // Zustand stores are used directly by their hook name
+            // e.g. useCartStore, useAuthStore
+            const zustandStore = storesByName.get(hookName);
+            if (zustandStore && zustandStore.metadata.storeType === "zustand") {
+                // Create both edges — can't distinguish read vs write without
+                // expensive type analysis
+                edges.push({
+                    from: node.id,
+                    to: zustandStore.id,
+                    type: "READS_FROM",
+                    metadata: { hookUsed: hookName, storeType: "zustand" },
+                });
+                edges.push({
+                    from: node.id,
+                    to: zustandStore.id,
+                    type: "WRITES_TO",
+                    metadata: { hookUsed: hookName, storeType: "zustand" },
+                });
+                continue;
+            }
+            // ─── Redux ────────────────────────────────────────────────────────────
+            // Redux uses useSelector (read) and useDispatch (write)
+            // Neither references a specific store by name so we connect
+            // to all Redux stores found in the codebase
+            if (REDUX_READ_HOOKS.includes(hookName)) {
+                for (const store of reduxStores) {
+                    edges.push({
+                        from: node.id,
+                        to: store.id,
+                        type: "READS_FROM",
+                        metadata: { hookUsed: hookName, storeType: "redux" },
+                    });
+                }
+                continue;
+            }
+            if (REDUX_WRITE_HOOKS.includes(hookName)) {
+                for (const store of reduxStores) {
+                    edges.push({
+                        from: node.id,
+                        to: store.id,
+                        type: "WRITES_TO",
+                        metadata: { hookUsed: hookName, storeType: "redux" },
+                    });
+                }
+                continue;
+            }
+            // ─── Context ──────────────────────────────────────────────────────────
+            // useContext(AuthContext) — the parser now extracts the argument name
+            // and stores it in metadata.contextRefs (e.g. ["AuthContext"]).
+            // We do a direct name lookup so the edge is always correct.
+            // useContext is read-only — no WRITES_TO edge here.
+            if (CONTEXT_HOOKS.includes(hookName)) {
+                const contextRefs = node.metadata.contextRefs;
+                if (!contextRefs || contextRefs.length === 0)
+                    continue;
+                for (const ref of contextRefs) {
+                    const contextStore = storesByName.get(ref);
+                    if (contextStore && contextStore.metadata.storeType === "context") {
+                        edges.push({
+                            from: node.id,
+                            to: contextStore.id,
+                            type: "READS_FROM",
+                            metadata: { hookUsed: hookName, storeType: "context" },
+                        });
+                    }
+                }
+                continue;
+            }
+            // ─── Recoil ───────────────────────────────────────────────────────────
+            if (RECOIL_READ_HOOKS.includes(hookName)) {
+                // Find recoil atoms referenced in this component
+                for (const ref of hooks) {
+                    const atomStore = storesByName.get(ref);
+                    if (atomStore && atomStore.metadata.storeType === "recoil") {
+                        edges.push({
+                            from: node.id,
+                            to: atomStore.id,
+                            type: "READS_FROM",
+                            metadata: { hookUsed: hookName, storeType: "recoil" },
+                        });
+                    }
+                }
+                continue;
+            }
+            if (RECOIL_WRITE_HOOKS.includes(hookName)) {
+                for (const ref of hooks) {
+                    const atomStore = storesByName.get(ref);
+                    if (atomStore && atomStore.metadata.storeType === "recoil") {
+                        edges.push({
+                            from: node.id,
+                            to: atomStore.id,
+                            type: "WRITES_TO",
+                            metadata: { hookUsed: hookName, storeType: "recoil" },
+                        });
+                    }
+                }
+                continue;
+            }
+            if (RECOIL_BOTH_HOOKS.includes(hookName)) {
+                for (const ref of hooks) {
+                    const atomStore = storesByName.get(ref);
+                    if (atomStore && atomStore.metadata.storeType === "recoil") {
+                        edges.push({
+                            from: node.id,
+                            to: atomStore.id,
+                            type: "READS_FROM",
+                            metadata: { hookUsed: hookName, storeType: "recoil" },
+                        });
+                        edges.push({
+                            from: node.id,
+                            to: atomStore.id,
+                            type: "WRITES_TO",
+                            metadata: { hookUsed: hookName, storeType: "recoil" },
+                        });
+                    }
+                }
+                continue;
+            }
+            // ─── Jotai ────────────────────────────────────────────────────────────
+            if (JOTAI_READ_HOOKS.includes(hookName)) {
+                for (const ref of hooks) {
+                    const atomStore = storesByName.get(ref);
+                    if (atomStore && atomStore.metadata.storeType === "jotai") {
+                        edges.push({
+                            from: node.id,
+                            to: atomStore.id,
+                            type: "READS_FROM",
+                            metadata: { hookUsed: hookName, storeType: "jotai" },
+                        });
+                    }
+                }
+                continue;
+            }
+            if (JOTAI_WRITE_HOOKS.includes(hookName)) {
+                for (const ref of hooks) {
+                    const atomStore = storesByName.get(ref);
+                    if (atomStore && atomStore.metadata.storeType === "jotai") {
+                        edges.push({
+                            from: node.id,
+                            to: atomStore.id,
+                            type: "WRITES_TO",
+                            metadata: { hookUsed: hookName, storeType: "jotai" },
+                        });
+                    }
+                }
+                continue;
+            }
+            if (JOTAI_BOTH_HOOKS.includes(hookName)) {
+                for (const ref of hooks) {
+                    const atomStore = storesByName.get(ref);
+                    if (atomStore && atomStore.metadata.storeType === "jotai") {
+                        edges.push({
+                            from: node.id,
+                            to: atomStore.id,
+                            type: "READS_FROM",
+                            metadata: { hookUsed: hookName, storeType: "jotai" },
+                        });
+                        edges.push({
+                            from: node.id,
+                            to: atomStore.id,
+                            type: "WRITES_TO",
+                            metadata: { hookUsed: hookName, storeType: "jotai" },
+                        });
+                    }
+                }
+                continue;
+            }
+        }
+    }
+    return edges;
+}

package/dist/graph/edges/testEdges.d.ts

@@ -0,0 +1,3 @@
+import type { CodeEdge } from "../../types.js";
+import type { LookupMaps } from "../buildLookup.js";
+export declare function detectTestEdges(lookup: LookupMaps, repoPath: string): CodeEdge[];

package/dist/graph/edges/testEdges.js

@@ -0,0 +1,143 @@
+//This file will detect the TEST edges from the test/story files to the components they are testing. 
+import path from "path";
+import fs from "fs";
+import { Project } from "ts-morph";
+import { isLocalImport } from "./importEdges.js";
+function getConfigPath(repoPath) {
+    const tsConfig = path.join(repoPath, "tsconfig.json");
+    const jsconfig = path.join(repoPath, "jsconfig.json");
+    if (fs.existsSync(tsConfig))
+        return tsConfig;
+    if (fs.existsSync(jsconfig))
+        return jsconfig;
+    return undefined;
+}
+function addFilesRecursively(dir, project) {
+    const IGNORE_DIRS = ["node_modules", "dist", "build", ".next", "coverage", ".git"];
+    const entries = fs.readdirSync(dir, { withFileTypes: true });
+    for (const entry of entries) {
+        if (entry.isDirectory()) {
+            if (IGNORE_DIRS.includes(entry.name))
+                continue;
+            addFilesRecursively(path.join(dir, entry.name), project);
+        }
+        else if (/\.(ts|tsx|js|jsx)$/.test(entry.name)) {
+            project.addSourceFileAtPath(path.join(dir, entry.name));
+        }
+    }
+}
+function resolveAlias(moduleSpecifier, repoPath, currentDir) {
+    // Try to read tsconfig paths
+    const tsconfigPath = path.join(repoPath, "tsconfig.json");
+    if (fs.existsSync(tsconfigPath)) {
+        try {
+            const tsconfig = JSON.parse(fs.readFileSync(tsconfigPath, "utf-8"));
+            const paths = tsconfig.compilerOptions?.paths ?? {};
+            const baseUrl = tsconfig.compilerOptions?.baseUrl ?? ".";
+            const base = path.join(repoPath, baseUrl);
+            // Check each alias — e.g. "@/*": ["./src/*"]
+            for (const [alias, targets] of Object.entries(paths)) {
+                const aliasPrefix = alias.replace("/*", "/");
+                if (moduleSpecifier.startsWith(aliasPrefix)) {
+                    const rest = moduleSpecifier.slice(aliasPrefix.length);
+                    const target = targets[0].replace("/*", "");
+                    return path.join(base, target, rest);
+                }
+            }
+        }
+        catch {
+            // malformed tsconfig — fall through
+        }
+    }
+    // Fallback — relative import
+    return path.join(currentDir, moduleSpecifier);
+}
+// ─── detectTestEdges ──────────────────────────────────────────────────────────
+//
+// Creates TESTS edges from TEST/STORY file nodes to the actual component/
+// function/hook nodes they import from production code.
+//
+// Resolution strategy:
+//   1. Find all TEST and STORY file nodes
+//   2. For each, read its import declarations via ts-morph
+//   3. Resolve each named import to its target file
+//   4. Look up the named export in nodesByFile to find the exact node
+//   5. Create TESTS edge: testNode → TESTS → productionNode
+export function detectTestEdges(lookup, repoPath) {
+    const edges = [];
+    const createdEdges = new Set();
+    //filter all TEST and STORY file nodes
+    const testFileNodes = [...lookup.fileNodesByPath.values()].filter(n => ["TEST", "STORY"].includes(n.type));
+    if (testFileNodes.length === 0)
+        return edges;
+    //setup ts-morph project for import resolution
+    const configPath = getConfigPath(repoPath);
+    const project = configPath
+        ? new Project({
+            tsConfigFilePath: configPath,
+            skipAddingFilesFromTsConfig: true, // we do not want it to consider node modules or other unwanted files. So we manually walk down the repo.
+        })
+        : new Project({ skipAddingFilesFromTsConfig: true });
+    addFilesRecursively(repoPath, project);
+    for (const testNode of testFileNodes) {
+        const absFilePath = path.join(repoPath, testNode.filePath);
+        const sourceFile = project.getSourceFile(absFilePath);
+        if (!sourceFile)
+            continue;
+        const importDecls = sourceFile.getImportDeclarations();
+        for (const importDecl of importDecls) {
+            const moduleSpecifier = importDecl.getModuleSpecifierValue();
+            if (!isLocalImport(moduleSpecifier))
+                continue; // we are not considering third party or library imports.
+            let resolvedPath;
+            const resolvedFile = importDecl.getModuleSpecifierSourceFile();
+            if (resolvedFile) {
+                resolvedPath = resolvedFile.getFilePath();
+            }
+            else {
+                //This code block will rarely hit because ts-morph will handlethe resolvedFile from the project
+                const currentDir = path.dirname(absFilePath);
+                let basePath = resolveAlias(moduleSpecifier, repoPath, currentDir);
+                const candidates = [
+                    basePath,
+                    basePath + ".ts", basePath + ".tsx",
+                    basePath + ".js", basePath + ".jsx",
+                    path.join(basePath, "index.ts"),
+                    path.join(basePath, "index.tsx"),
+                ];
+                resolvedPath = candidates.find(c => fs.existsSync(c));
+            }
+            if (!resolvedPath)
+                continue;
+            const targetRelative = path.relative(repoPath, resolvedPath).replace(/\\/g, "/");
+            // Get named imports — { Button } from "./Button"
+            const namedImports = importDecl.getNamedImports();
+            for (const namedImport of namedImports) {
+                const importedName = namedImport.getName();
+                // Find the actual production node by name in the target file
+                const nodesInFile = lookup.nodesByFile.get(targetRelative) ?? [];
+                const targetNode = nodesInFile.find(n => n.name === importedName);
+                if (!targetNode)
+                    continue;
+                // Skip if target is also a TEST/STORY node — test importing test
+                if (targetNode.type === "TEST" || targetNode.type === "STORY")
+                    continue;
+                const edgeKey = `${testNode.id}→${targetNode.id}`;
+                if (createdEdges.has(edgeKey))
+                    continue;
+                createdEdges.add(edgeKey);
+                edges.push({
+                    from: testNode.id,
+                    to: targetNode.id,
+                    type: "TESTS",
+                    metadata: {
+                        importPath: moduleSpecifier,
+                        testFileType: testNode.type,
+                    },
+                });
+            }
+        }
+    }
+    console.log(`  TESTS edges: ${edges.length}`);
+    return edges;
+}

package/dist/graph/edges/utils.d.ts

@@ -0,0 +1,2 @@
+import type { CodeNode } from "../../types.js";
+export declare function closestByPath(candidates: CodeNode[], referencePath: string): CodeNode;

package/dist/graph/edges/utils.js

@@ -0,0 +1,25 @@
+// Picks the node whose filePath shares the most leading path segments
+// with the reference path. When multiple nodes have the same name (e.g.
+// two files both export a function called "handleSubmit"), this heuristic
+// selects the one physically closest to the caller in the directory tree.
+export function closestByPath(candidates, referencePath) {
+    const refParts = referencePath.split("/");
+    let best = candidates[0];
+    let bestScore = 0;
+    for (const candidate of candidates) {
+        const parts = candidate.filePath.split("/");
+        let score = 0;
+        const len = Math.min(refParts.length, parts.length);
+        for (let i = 0; i < len; i++) {
+            if (refParts[i] === parts[i])
+                score++;
+            else
+                break;
+        }
+        if (score > bestScore) {
+            bestScore = score;
+            best = candidate;
+        }
+    }
+    return best;
+}

package/dist/graph/index.d.ts

@@ -0,0 +1,6 @@
+import type { BackendRouteNode, CodeEdge, CodeNode, ProjectFingerprint, RouteNode } from "../types.js";
+export interface EdgeDetectionResult {
+    edges: CodeEdge[];
+    ghostNodes: CodeNode[];
+}
+export declare function detectEdges(nodes: CodeNode[], routeNodes: (RouteNode | BackendRouteNode)[], repoPath: string, fingerprint: ProjectFingerprint): EdgeDetectionResult;

package/dist/graph/index.js

@@ -0,0 +1,65 @@
+import { buildLookupMaps } from "./buildLookup.js";
+import { detectCallEdges } from "./edges/callEdges.js";
+import { detectEventEdges } from "./edges/eventEdges.js";
+import { detectGuardEdges } from "./edges/guardEdges.js";
+import { detectHookEdges } from "./edges/hookEdges.js";
+import { detectImportEdges } from "./edges/importEdges.js";
+import { detectPropEdges } from "./edges/propEdges.js";
+import { detectRouteEdges } from "./edges/routeEdge.js";
+import { detectStateEdges } from "./edges/stateEdges.js";
+import { detectTestEdges } from "./edges/testEdges.js";
+export function detectEdges(nodes, routeNodes, repoPath, fingerprint) {
+    console.log(`Building lookup maps for edge detection for ${nodes.length} nodes...`);
+    //building lookup maps
+    const lookupMp = buildLookupMaps(nodes);
+    console.log("Running edge detectors...");
+    // importEdges MUST run before callEdges — it populates lookupMp.thirdPartyImportAliases
+    // as a side-effect, and callEdges reads that map to resolve third-party CALLS edges.
+    const importResult = detectImportEdges(lookupMp, repoPath);
+    const importEdges = importResult.edges;
+    const callResult = detectCallEdges(nodes, lookupMp);
+    const callEdges = callResult.edges;
+    const stateEdges = detectStateEdges(nodes, lookupMp);
+    const propEdges = detectPropEdges(nodes, lookupMp, repoPath);
+    const hookEdges = detectHookEdges(nodes, lookupMp);
+    const eventResults = detectEventEdges(lookupMp, repoPath);
+    const routeEdges = detectRouteEdges(nodes, lookupMp);
+    // GUARDS — middleware to route protection
+    const guardEdges = detectGuardEdges(nodes, lookupMp, routeNodes, repoPath, fingerprint);
+    const testEdges = detectTestEdges(lookupMp, repoPath); // This does not needs nodes, as it detect edges from the file
+    // Collect all dynamically-created third-party method nodes (dedup by id)
+    const newThirdPartyNodesMap = new Map();
+    for (const n of [...importResult.thirdPartyMethodNodes, ...callResult.newThirdPartyNodes]) {
+        if (!newThirdPartyNodesMap.has(n.id))
+            newThirdPartyNodesMap.set(n.id, n);
+    }
+    const newThirdPartyNodes = [...newThirdPartyNodesMap.values()];
+    console.log(`Running edge detectors...`);
+    console.log(`  CALLS edges: ${callEdges.length}`);
+    console.log(`  IMPORTS edges: ${importEdges.length}`);
+    console.log(`  STATE edges: ${stateEdges.length}`);
+    console.log(`  PROP edges: ${propEdges.length}`);
+    console.log(`  HOOK edges:    ${hookEdges.length}`);
+    console.log(`  EVENT edges: ${eventResults.edges.length}`);
+    console.log(`  ROUTE edges:   ${routeEdges.length}`);
+    console.log(`  GUARD edges: ${guardEdges.length}`);
+    console.log(`  TEST edges: ${testEdges.length}`);
+    console.log(`  Ghost nodes created: ${eventResults.ghostNodes.length}`);
+    console.log(`  Third-party method nodes: ${newThirdPartyNodes.length}`);
+    const allEdges = [
+        ...callEdges,
+        ...importEdges,
+        ...stateEdges,
+        ...propEdges,
+        ...hookEdges,
+        ...eventResults.edges,
+        ...routeEdges,
+        ...guardEdges,
+        ...testEdges,
+    ];
+    console.log(`Total edges detected: ${allEdges.length}`);
+    return {
+        edges: allEdges,
+        ghostNodes: [...eventResults.ghostNodes, ...newThirdPartyNodes],
+    };
+}

package/dist/graph/index.test.d.ts

@@ -0,0 +1 @@
+export {};