devlensio 0.2.0

package/dist/parser/extractors/functions.js

@@ -0,0 +1,240 @@
+import { SyntaxKind } from "ts-morph";
+import { returnsJSX } from "./components.js";
+import { detectFunctionDirective } from "../directives.js";
+import { extractParams, extractReturnTypeAnnotation, extractBareTypeNames, extractReferencedInterfaces, } from "../typeUtils.js";
+// these are used to detect the routes in the Nextjs
+const HTTP_METHOD_EXPORTS = new Set(["GET", "POST", "PUT", "DELETE", "PATCH", "HEAD", "OPTIONS"]);
+function makeId(filePath, name) {
+    return `${filePath}::${name}`;
+}
+function extractFunctionCalls(node) {
+    const calls = node.getDescendantsOfKind(SyntaxKind.CallExpression);
+    const names = [];
+    for (const call of calls) {
+        const name = call.getExpression().getText();
+        // Skip hooks, they are handled by hooks extractor
+        if (name.startsWith("use"))
+            continue;
+        // Skip console calls, they are noise
+        if (name.startsWith("console"))
+            continue;
+        names.push(name);
+    }
+    return [...new Set(names)];
+}
+function extractHookCalls(node) {
+    const calls = node.getDescendantsOfKind(SyntaxKind.CallExpression);
+    const hooks = [];
+    for (const call of calls) {
+        const name = call.getExpression().getText();
+        // Only capture custom hooks — use[A-Z] pattern
+        // Built-in React hooks (useState etc.) are not in our node graph
+        if (/^use[A-Z]/.test(name))
+            hooks.push(name);
+    }
+    return [...new Set(hooks)];
+}
+function extractApiCalls(node) {
+    const calls = node.getDescendantsOfKind(SyntaxKind.CallExpression);
+    const apiCalls = [];
+    for (const call of calls) {
+        const text = call.getText();
+        const expr = call.getExpression().getText();
+        // ─── fetch ────────────────────────────────────────────────────────────────
+        if (expr === "fetch") {
+            const args = call.getArguments();
+            if (args.length > 0)
+                apiCalls.push(`fetch(${args[0].getText()})`);
+        }
+        // ─── axios ────────────────────────────────────────────────────────────────
+        if (expr === "axios.get" ||
+            expr === "axios.post" ||
+            expr === "axios.put" ||
+            expr === "axios.delete" ||
+            expr === "axios.patch" ||
+            expr === "axios") {
+            const args = call.getArguments();
+            if (args.length > 0)
+                apiCalls.push(`${expr}(${args[0].getText()})`);
+        }
+        // ─── React Query (useQuery, useMutation, useInfiniteQuery) ────────────────
+        if (expr === "useQuery" ||
+            expr === "useMutation" ||
+            expr === "useInfiniteQuery" ||
+            expr === "useSuspenseQuery") {
+            const args = call.getArguments();
+            if (args.length > 0)
+                apiCalls.push(`${expr}(${args[0].getText()})`);
+        }
+        // ─── SWR ──────────────────────────────────────────────────────────────────
+        if (expr === "useSWR" || expr === "useSWRMutation") {
+            const args = call.getArguments();
+            if (args.length > 0)
+                apiCalls.push(`${expr}(${args[0].getText()})`);
+        }
+    }
+    return [...new Set(apiCalls)];
+}
+function hasErrorHandling(node) {
+    const tryCatch = node.getDescendantsOfKind(SyntaxKind.TryStatement);
+    return tryCatch.length > 0;
+}
+function extractThrowStatements(node) {
+    const throws = node.getDescendantsOfKind(SyntaxKind.ThrowStatement);
+    return throws.length > 0;
+}
+export function extractFunctions(file, fileDirective = null) {
+    const nodes = [];
+    const filePath = file.getFilePath();
+    // ─── Function Declarations ─────────────────────────────────────────────────
+    for (const fn of file.getFunctions()) {
+        const name = fn.getName();
+        if (!name)
+            continue;
+        // Skip React components (uppercase and must return JSX) — handled by components extractor.
+        // Exception: HTTP method exports (GET, POST, etc.) are uppercase but are
+        // route handlers, not components. Captured in the dedicated section below.
+        if (/^[A-Z]/.test(name) && !HTTP_METHOD_EXPORTS.has(name) && returnsJSX(fn))
+            continue;
+        // Skip hooks - handled by hooks extractor
+        if (/^use[A-Z]/.test(name))
+            continue;
+        const typedParams = extractParams(fn);
+        const calls = extractFunctionCalls(fn);
+        const hookCalls = extractHookCalls(fn);
+        const apiCalls = extractApiCalls(fn);
+        const isAsync = fn.isAsync();
+        const hasErrors = hasErrorHandling(fn);
+        const throws = extractThrowStatements(fn);
+        const renderingBoundary = detectFunctionDirective(fn.getBody()) ?? fileDirective;
+        const returnType = extractReturnTypeAnnotation(fn);
+        const bareTypeNames = extractBareTypeNames([...typedParams.map((p) => p.type), returnType]);
+        const referencedTypes = extractReferencedInterfaces(file, bareTypeNames);
+        nodes.push({
+            id: makeId(filePath, name),
+            name,
+            type: "FUNCTION",
+            filePath,
+            startLine: fn.getStartLineNumber(),
+            endLine: fn.getEndLineNumber(),
+            rawCode: fn.getText(),
+            metadata: {
+                params: typedParams.map((p) => p.name),
+                parameters: typedParams,
+                returnType,
+                referencedTypes,
+                calls,
+                hookCalls,
+                apiCalls,
+                isAsync,
+                hasErrorHandling: hasErrors,
+                throws,
+                lineCount: fn.getEndLineNumber() - fn.getStartLineNumber(),
+                isHttpHandler: HTTP_METHOD_EXPORTS.has(name),
+                httpMethod: HTTP_METHOD_EXPORTS.has(name) ? name : undefined,
+                ...(renderingBoundary !== null && { renderingBoundary }),
+            },
+        });
+    }
+    // ─── Arrow Function Declarations ───────────────────────────────────────────
+    for (const variable of file.getVariableDeclarations()) {
+        const name = variable.getName();
+        // Skip React components and not nextJs HTTP routes
+        if (/^[A-Z]/.test(name) && !HTTP_METHOD_EXPORTS.has(name))
+            continue;
+        // Skip hooks
+        if (/^use[A-Z]/.test(name))
+            continue;
+        const initializer = variable.getInitializer();
+        if (!initializer)
+            continue;
+        const isArrow = initializer.getKind() === SyntaxKind.ArrowFunction;
+        if (!isArrow)
+            continue;
+        const typedParams = extractParams(initializer);
+        const calls = extractFunctionCalls(initializer);
+        const hookCalls = extractHookCalls(initializer);
+        const apiCalls = extractApiCalls(initializer);
+        const isAsync = initializer.getText().startsWith("async");
+        const hasErrors = hasErrorHandling(initializer);
+        const throws = extractThrowStatements(initializer);
+        const renderingBoundary = detectFunctionDirective(initializer.getBody?.()) ?? fileDirective;
+        const returnType = extractReturnTypeAnnotation(initializer);
+        const bareTypeNames = extractBareTypeNames([...typedParams.map((p) => p.type), returnType]);
+        const referencedTypes = extractReferencedInterfaces(file, bareTypeNames);
+        nodes.push({
+            id: makeId(filePath, name),
+            name,
+            type: "FUNCTION",
+            filePath,
+            startLine: variable.getStartLineNumber(),
+            endLine: variable.getEndLineNumber(),
+            rawCode: variable.getText(),
+            metadata: {
+                params: typedParams.map((p) => p.name),
+                parameters: typedParams,
+                returnType,
+                referencedTypes,
+                calls,
+                hookCalls,
+                apiCalls,
+                isAsync,
+                hasErrorHandling: hasErrors,
+                throws,
+                lineCount: variable.getEndLineNumber() - variable.getStartLineNumber(),
+                isHttpHandler: HTTP_METHOD_EXPORTS.has(name),
+                httpMethod: HTTP_METHOD_EXPORTS.has(name) ? name : undefined,
+                ...(renderingBoundary !== null && { renderingBoundary }),
+            },
+        });
+    }
+    // ─── HTTP Method Exports (re-exported via export { GET } pattern) ──────────
+    //
+    // Handles the case where a route.ts re-exports a handler defined elsewhere:
+    //   import { myHandler } from "./handlers.js";
+    //   export { myHandler as GET };
+    //
+    // In this case getFunctions() and getVariableDeclarations() won't find GET.
+    // We detect export specifiers that alias to an HTTP method name.
+    for (const exportDecl of file.getExportDeclarations()) {
+        for (const specifier of exportDecl.getNamedExports()) {
+            const exportedName = specifier.getAliasNode()?.getText()
+                ?? specifier.getName();
+            if (!HTTP_METHOD_EXPORTS.has(exportedName))
+                continue;
+            // The local name is what was imported — use it to find the original node
+            const localName = specifier.getName();
+            // Check if we already captured it above (direct export)
+            const alreadyCaptured = nodes.some(n => n.name === exportedName);
+            if (alreadyCaptured)
+                continue;
+            // We can't get line numbers reliably for re-exports, so use the
+            // export declaration's position as a proxy
+            nodes.push({
+                id: makeId(filePath, exportedName),
+                name: exportedName,
+                type: "FUNCTION",
+                filePath,
+                startLine: exportDecl.getStartLineNumber(),
+                endLine: exportDecl.getEndLineNumber(),
+                rawCode: exportDecl.getText(),
+                metadata: {
+                    params: [],
+                    calls: [],
+                    apiCalls: [],
+                    isAsync: false,
+                    hasErrorHandling: false,
+                    throws: false,
+                    lineCount: 1,
+                    isHttpHandler: true,
+                    httpMethod: exportedName,
+                    // Record that this is a re-export so routeEdges can follow
+                    // the chain to the actual implementation if needed
+                    isReExport: true,
+                    reExportedFrom: localName,
+                },
+            });
+        }
+    }
+    return nodes;
+}

package/dist/parser/extractors/hooks.d.ts

@@ -0,0 +1,4 @@
+import { SourceFile } from "ts-morph";
+import type { CodeNode } from "../../types.js";
+import { type RenderingBoundary } from "../directives.js";
+export declare function extractHooks(file: SourceFile, fileDirective?: RenderingBoundary): CodeNode[];

package/dist/parser/extractors/hooks.js

@@ -0,0 +1,128 @@
+import { SyntaxKind } from "ts-morph";
+import { detectFunctionDirective } from "../directives.js";
+import { extractParams, extractBareTypeNames, extractReferencedInterfaces, } from "../typeUtils.js";
+function makeId(filePath, name) {
+    return `${filePath}::${name}`;
+}
+function extractDependencies(node) {
+    const calls = node.getDescendantsOfKind(SyntaxKind.CallExpression);
+    const deps = [];
+    for (const call of calls) {
+        const name = call.getExpression().getText();
+        if (name.startsWith("use")) {
+            deps.push(name);
+        }
+    }
+    return [...new Set(deps)];
+}
+function extractContextRefs(node) {
+    const refs = [];
+    for (const call of node.getDescendantsOfKind(SyntaxKind.CallExpression)) {
+        if (call.getExpression().getText() === "useContext") {
+            const arg = call.getArguments()[0];
+            if (arg)
+                refs.push(arg.getText());
+        }
+    }
+    return [...new Set(refs)];
+}
+// Try explicit annotation first; fall back to shape heuristic.
+function extractReturnType(node) {
+    const explicit = node.getReturnTypeNode?.()?.getText();
+    if (explicit)
+        return explicit;
+    const returnStatements = node.getDescendantsOfKind(SyntaxKind.ReturnStatement);
+    if (returnStatements.length === 0)
+        return "void";
+    for (const ret of returnStatements) {
+        const expr = ret.getExpression();
+        if (!expr)
+            continue;
+        if (expr.getKind() === SyntaxKind.ArrayLiteralExpression)
+            return "array";
+        if (expr.getKind() === SyntaxKind.ObjectLiteralExpression)
+            return "object";
+    }
+    return "unknown";
+}
+export function extractHooks(file, fileDirective = null) {
+    const nodes = [];
+    const filePath = file.getFilePath();
+    // ─── Function Declaration Hooks ────────────────────────────────────────────
+    // e.g. function useAuth() { ... }
+    for (const fn of file.getFunctions()) {
+        const name = fn.getName();
+        if (!name)
+            continue;
+        // Hooks must start with "use" followed by uppercase
+        if (!/^use[A-Z]/.test(name))
+            continue;
+        const dependencies = extractDependencies(fn);
+        const returnType = extractReturnType(fn);
+        const isAsync = fn.isAsync();
+        const contextRefs = extractContextRefs(fn);
+        const renderingBoundary = detectFunctionDirective(fn.getBody()) ?? fileDirective;
+        const typedParams = extractParams(fn);
+        const bareTypeNames = extractBareTypeNames([...typedParams.map((p) => p.type), returnType]);
+        const referencedTypes = extractReferencedInterfaces(file, bareTypeNames);
+        nodes.push({
+            id: makeId(filePath, name),
+            name,
+            type: "HOOK",
+            filePath,
+            startLine: fn.getStartLineNumber(),
+            endLine: fn.getEndLineNumber(),
+            rawCode: fn.getText(),
+            metadata: {
+                dependencies,
+                contextRefs,
+                returnType,
+                parameters: typedParams,
+                referencedTypes,
+                isAsync,
+                ...(renderingBoundary !== null && { renderingBoundary }),
+            },
+        });
+    }
+    // ─── Arrow Function Hooks ──────────────────────────────────────────────────
+    // e.g. const useAuth = () => { ... }
+    for (const variable of file.getVariableDeclarations()) {
+        const name = variable.getName();
+        // Hooks must start with "use" followed by uppercase
+        if (!/^use[A-Z]/.test(name))
+            continue;
+        const initializer = variable.getInitializer();
+        if (!initializer)
+            continue;
+        const isArrow = initializer.getKind() === SyntaxKind.ArrowFunction;
+        if (!isArrow)
+            continue;
+        const dependencies = extractDependencies(initializer);
+        const returnType = extractReturnType(initializer);
+        const isAsync = initializer.asKind(SyntaxKind.ArrowFunction)?.isAsync() ?? false;
+        const contextRefs = extractContextRefs(initializer);
+        const renderingBoundary = detectFunctionDirective(initializer.getBody?.()) ?? fileDirective;
+        const typedParams = extractParams(initializer);
+        const bareTypeNames = extractBareTypeNames([...typedParams.map((p) => p.type), returnType]);
+        const referencedTypes = extractReferencedInterfaces(file, bareTypeNames);
+        nodes.push({
+            id: makeId(filePath, name),
+            name,
+            type: "HOOK",
+            filePath,
+            startLine: variable.getStartLineNumber(),
+            endLine: variable.getEndLineNumber(),
+            rawCode: variable.getText(),
+            metadata: {
+                dependencies,
+                contextRefs,
+                returnType,
+                parameters: typedParams,
+                referencedTypes,
+                isAsync,
+                ...(renderingBoundary !== null && { renderingBoundary }),
+            },
+        });
+    }
+    return nodes;
+}

package/dist/parser/extractors/stores.d.ts

@@ -0,0 +1,3 @@
+import { SourceFile } from "ts-morph";
+import type { CodeNode } from "../../types.js";
+export declare function extractStores(file: SourceFile): CodeNode[];

package/dist/parser/extractors/stores.js

@@ -0,0 +1,181 @@
+import { SyntaxKind } from "ts-morph";
+function makeId(filePath, name) {
+    return `${filePath}::${name}`;
+}
+function extractStateShape(node, storeType) {
+    const properties = [];
+    const objLiterals = node.getDescendantsOfKind(SyntaxKind.ObjectLiteralExpression);
+    if (objLiterals.length === 0)
+        return properties;
+    //Takes the first object literal as the state shape
+    // Extracts all property names from that object
+    // Example: create((set) => ({ items: [], total: 0 })) → ["items", "total"]
+    if (storeType === "zustand") {
+        // First object literal is the state shape
+        const firstObj = objLiterals[0];
+        for (const prop of firstObj.getProperties()) {
+            const propName = prop.getName ? prop.getName() : null;
+            if (propName)
+                properties.push(propName);
+        }
+    }
+    // Looks for an initialState property within object literals
+    // Extracts properties from inside the initialState object
+    // Example: createSlice({ initialState: { items: [], total: 0 } }) → ["items", "total"]
+    if (storeType === "redux") {
+        // Look specifically for initialState object
+        for (const obj of objLiterals) {
+            for (const prop of obj.getProperties()) {
+                const propName = prop.getName ? prop.getName() : null;
+                if (propName === "initialState") {
+                    const initializer = prop.getInitializer();
+                    if (!initializer || initializer.getKind() !== SyntaxKind.ObjectLiteralExpression)
+                        continue;
+                    for (const innerProp of initializer.getProperties()) {
+                        const innerName = innerProp.getName ? innerProp.getName() : null;
+                        if (innerName)
+                            properties.push(innerName);
+                    }
+                }
+            }
+        }
+    }
+    //  Looks for a key property and extracts its value as the state identifier
+    // Returns the key name (not property names)
+    // Example: atom({ key: "cartState", default: { items: [] } }) → ["cartState"]
+    if (storeType === "recoil") {
+        // Recoil has a single default value not a shape
+        // We store the key name as the state identifier
+        for (const obj of objLiterals) {
+            for (const prop of obj.getProperties()) {
+                const propName = prop.getName ? prop.getName() : null;
+                if (propName === "key") {
+                    const initializer = prop.getInitializer
+                        ? prop.getInitializer()
+                        : null;
+                    if (initializer)
+                        properties.push(initializer.getText().replace(/['"]/g, ""));
+                }
+            }
+        }
+    }
+    if (storeType === "jotai") {
+        // Jotai atoms don't have a shape
+        // We just return empty — the atom name itself is the identifier
+        return [];
+    }
+    return properties;
+}
+//This function will extract action names from different store types.
+function extractActions(node, storeType) {
+    const actions = [];
+    const objLiterals = node.getDescendantsOfKind(SyntaxKind.ObjectLiteralExpression);
+    //  Finds function-valued properties in the first object literal
+    // Extracts names of arrow functions and function expressions
+    // Example: create((set) => ({ addItem: () => set({ items: [] }) })) → ["addItem"]
+    if (storeType === "zustand") {
+        // Actions are function-valued properties in the first object
+        for (const obj of objLiterals) {
+            for (const prop of obj.getProperties()) {
+                const initializer = prop.getInitializer
+                    ? prop.getInitializer()
+                    : null;
+                if (!initializer)
+                    continue;
+                if (initializer.getKind() === SyntaxKind.ArrowFunction ||
+                    initializer.getKind() === SyntaxKind.FunctionExpression) {
+                    const name = prop.getName ? prop.getName() : null;
+                    if (name)
+                        actions.push(name);
+                }
+            }
+        }
+    }
+    //   Looks specifically inside a reducers object
+    // Extracts property names from the reducers object
+    // Example: createSlice({ reducers: { addItem: (state) => {} } }) → ["addItem"]
+    if (storeType === "redux") {
+        // Actions live inside the reducers object specifically
+        for (const obj of objLiterals) {
+            for (const prop of obj.getProperties()) {
+                const propName = prop.getName ? prop.getName() : null;
+                if (propName === "reducers") {
+                    const initializer = prop.getInitializer();
+                    if (!initializer || initializer.getKind() !== SyntaxKind.ObjectLiteralExpression)
+                        continue;
+                    for (const reducerProp of initializer.getProperties()) {
+                        const reducerName = reducerProp.getName ? reducerProp.getName() : null;
+                        if (reducerName)
+                            actions.push(reducerName);
+                    }
+                }
+            }
+        }
+    }
+    if (storeType === "recoil" || storeType === "jotai") {
+        // No actions defined inside atom/selector definitions
+        // Actions happen via setters in components
+        return [];
+    }
+    return actions;
+}
+function detectStoreType(text) {
+    if (text.startsWith("create(") || text.startsWith("create<"))
+        return "zustand";
+    if (text.includes("createSlice") || text.includes("createReducer"))
+        return "redux";
+    if (text.includes("createContext"))
+        return "context";
+    if (text.startsWith("atom(") && text.includes("key:"))
+        return "recoil";
+    if (text.startsWith("selector(") || text.startsWith("atomFamily("))
+        return "recoil";
+    if (text.startsWith("atom(") && !text.includes("key:"))
+        return "jotai";
+    return "unknown";
+}
+export function extractStores(file) {
+    const nodes = [];
+    const filePath = file.getFilePath();
+    for (const variable of file.getVariableDeclarations()) {
+        const name = variable.getName();
+        const initializer = variable.getInitializer();
+        if (!initializer)
+            continue;
+        const text = initializer.getText();
+        // ─── Zustand Store ────────────────────────────────────────────────────────
+        // e.g. const useCartStore = create((set) => ({ ... }))
+        const isZustand = text.startsWith("create(") || text.startsWith("create<");
+        // ─── Redux Slice ──────────────────────────────────────────────────────────
+        // e.g. const cartSlice = createSlice({ name, initialState, reducers })
+        const isRedux = text.startsWith("createSlice(") || text.startsWith("createReducer(");
+        // ---- Recoil Atom Selector ──────────────────────────────────────────────────────────
+        const isRecoil = text.startsWith("atom(") || text.startsWith("selector(") || text.startsWith("atomFamily(") || text.startsWith("selectorFamily(");
+        // ----- Jotai Atom ──────────────────────────────────────────────────────────
+        const isJotai = text.startsWith("atom(") && !text.includes("key:"); // recoil atoms always have a key property , jotai atoms do not
+        // ─── React Context ────────────────────────────────────────────────────────
+        // e.g. const AuthContext = createContext(null)
+        const isContext = text.startsWith("createContext(") ||
+            text.startsWith("React.createContext(");
+        if (!isZustand && !isRedux && !isContext && !isRecoil && !isJotai)
+            continue;
+        const storeType = detectStoreType(text);
+        const stateShape = extractStateShape(initializer, storeType);
+        const actions = extractActions(initializer, storeType);
+        nodes.push({
+            id: makeId(filePath, name),
+            name,
+            type: "STATE_STORE",
+            filePath,
+            startLine: variable.getStartLineNumber(),
+            endLine: variable.getEndLineNumber(),
+            rawCode: variable.getText(),
+            metadata: {
+                storeType,
+                stateShape, // e.g. ["items", "total", "isOpen"]
+                actions, // e.g. ["addItem", "removeItem", "clearCart"]
+            },
+        });
+    }
+    return nodes;
+}

package/dist/parser/index.d.ts

@@ -0,0 +1,14 @@
+import type { CodeNode } from "../types.js";
+export interface ParserResult {
+    nodes: CodeNode[];
+    stats: {
+        totalFiles: number;
+        totalNodes: number;
+        componentCount: number;
+        hookCount: number;
+        functionCount: number;
+        storeCount: number;
+        skippedFiles: number;
+    };
+}
+export declare function parseRepo(repoPath: string): ParserResult;