devlensio 0.6.2 → 1.0.1

package/dist/parser/classes.test.js

@@ -0,0 +1,360 @@
+import fs from "fs";
+import path from "path";
+import os from "os";
+import { parseRepo } from "./index.js";
+// ─── Helpers (mirror index.test.ts) ─────────────────────────────────────────
+function createFakeRepo(files) {
+    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "devlens-classes-test-"));
+    for (const [filePath, content] of Object.entries(files)) {
+        const fullPath = path.join(tmpDir, filePath);
+        fs.mkdirSync(path.dirname(fullPath), { recursive: true });
+        fs.writeFileSync(fullPath, content);
+    }
+    return tmpDir;
+}
+function deleteFakeRepo(repoPath) {
+    fs.rmSync(repoPath, { recursive: true, force: true });
+}
+function nodesOf(repoPath, type) {
+    return parseRepo(repoPath).nodes.filter((n) => n.type === type);
+}
+// ─── Tests ───────────────────────────────────────────────────────────────────
+describe("class extraction", () => {
+    // 1. Plain class, no methods → CLASS node only
+    it("emits a CLASS node for a plain class with no methods", () => {
+        const repo = createFakeRepo({
+            "src/empty.ts": `export class Marker {}`,
+        });
+        const cls = nodesOf(repo, "CLASS").find((n) => n.name === "Marker");
+        expect(cls).toBeDefined();
+        expect(cls?.metadata.methodNames).toEqual([]);
+        expect(cls?.metadata.extendsType).toBeUndefined();
+        expect(cls?.metadata.implementsTypes).toEqual([]);
+        deleteFakeRepo(repo);
+    });
+    // 2. Constructor-only class → Class.constructor METHOD
+    it("emits a constructor as a METHOD node", () => {
+        const repo = createFakeRepo({
+            "src/svc.ts": `
+        export class Service {
+          constructor(private api: string) {}
+        }
+      `,
+        });
+        const ctor = nodesOf(repo, "METHOD").find((n) => n.name === "Service.constructor");
+        expect(ctor).toBeDefined();
+        expect(ctor?.metadata.isConstructor).toBe(true);
+        expect(ctor?.metadata.className).toBe("Service");
+        const cls = nodesOf(repo, "CLASS").find((n) => n.name === "Service");
+        expect(cls?.metadata.constructorParams).toEqual(["api"]);
+        deleteFakeRepo(repo);
+    });
+    // 3. Private methods (private foo, #bar) → isPrivate
+    it("flags private and #-private methods", () => {
+        const repo = createFakeRepo({
+            "src/priv.ts": `
+        export class Secrets {
+          private hidden() { return 1; }
+          #trulyHidden() { return 2; }
+          visible() { return this.hidden() + this.#trulyHidden(); }
+        }
+      `,
+        });
+        const methods = nodesOf(repo, "METHOD");
+        const hidden = methods.find((n) => n.name === "Secrets.hidden");
+        const truly = methods.find((n) => n.name === "Secrets.trulyHidden");
+        const visible = methods.find((n) => n.name === "Secrets.visible");
+        expect(hidden?.metadata.isPrivate).toBe(true);
+        expect(truly?.metadata.isPrivate).toBe(true);
+        expect(visible?.metadata.isPrivate).toBe(false);
+        // #-name is stripped for the node name, and this.#trulyHidden() rewrites
+        // to the stripped name
+        expect(visible?.metadata.calls).toContain("Secrets.hidden");
+        expect(visible?.metadata.calls).toContain("Secrets.trulyHidden");
+        deleteFakeRepo(repo);
+    });
+    // 4. Static methods → isStatic
+    it("flags static methods", () => {
+        const repo = createFakeRepo({
+            "src/static.ts": `
+        export class MathUtils {
+          static add(a: number, b: number) { return a + b; }
+          instance() { return MathUtils.add(1, 2); }
+        }
+      `,
+        });
+        const methods = nodesOf(repo, "METHOD");
+        expect(methods.find((n) => n.name === "MathUtils.add")?.metadata.isStatic).toBe(true);
+        expect(methods.find((n) => n.name === "MathUtils.instance")?.metadata.isStatic).toBe(false);
+        // Static self-reference stays as the dotted class name → resolvable later
+        expect(methods.find((n) => n.name === "MathUtils.instance")?.metadata.calls).toContain("MathUtils.add");
+        deleteFakeRepo(repo);
+    });
+    // 5. Abstract class + abstract method
+    it("flags abstract classes and abstract methods", () => {
+        const repo = createFakeRepo({
+            "src/abs.ts": `
+        export abstract class Shape {
+          abstract area(): number;
+          label() { return "shape"; }
+        }
+      `,
+        });
+        const cls = nodesOf(repo, "CLASS").find((n) => n.name === "Shape");
+        expect(cls?.metadata.isAbstract).toBe(true);
+        const methods = nodesOf(repo, "METHOD");
+        expect(methods.find((n) => n.name === "Shape.area")?.metadata.isAbstract).toBe(true);
+        expect(methods.find((n) => n.name === "Shape.label")?.metadata.isAbstract).toBe(false);
+        deleteFakeRepo(repo);
+    });
+    // 6. Getter/setter → isAccessor
+    it("emits getters and setters as METHOD nodes with isAccessor", () => {
+        const repo = createFakeRepo({
+            "src/acc.ts": `
+        export class Temperature {
+          private celsius = 0;
+          get fahrenheit() { return this.celsius * 9 / 5 + 32; }
+          set fahrenheit(v: number) { this.celsius = (v - 32) * 5 / 9; }
+        }
+      `,
+        });
+        const methods = nodesOf(repo, "METHOD");
+        const getter = methods.find((n) => n.name === "Temperature.fahrenheit" && n.metadata.isAccessor === "get");
+        const setter = methods.find((n) => n.name === "Temperature.fahrenheit" && n.metadata.isAccessor === "set");
+        expect(getter).toBeDefined();
+        expect(setter).toBeDefined();
+        deleteFakeRepo(repo);
+    });
+    // 7. Generic class → typeParams
+    it("captures type parameters on generic classes", () => {
+        const repo = createFakeRepo({
+            "src/gen.ts": `export class Box<T> { value?: T; }`,
+        });
+        const cls = nodesOf(repo, "CLASS").find((n) => n.name === "Box");
+        expect(cls?.metadata.typeParams).toEqual(["T"]);
+        deleteFakeRepo(repo);
+    });
+    // 8. Decorated class (NestJS-style)
+    it("captures class decorators", () => {
+        const repo = createFakeRepo({
+            "src/dec.ts": `
+        function Injectable() { return (t: any) => t; }
+        function Controller(p: string) { return (t: any) => t; }
+        @Controller("cats")
+        @Injectable()
+        export class CatsService {}
+      `,
+        });
+        const cls = nodesOf(repo, "CLASS").find((n) => n.name === "CatsService");
+        expect(cls?.metadata.decorators).toContain("Injectable");
+        expect(cls?.metadata.decorators).toContain("Controller");
+        deleteFakeRepo(repo);
+    });
+    // 9. React class component → CLASS (not COMPONENT) + propsType/stateType
+    it("emits React class components as CLASS nodes with props/state types", () => {
+        const repo = createFakeRepo({
+            "src/Dashboard.tsx": `
+        import React from "react";
+        interface DashboardProps { title: string; }
+        interface DashboardState { open: boolean; }
+        export class Dashboard extends React.Component<DashboardProps, DashboardState> {
+          render() { return <div>{this.props.title}</div>; }
+        }
+      `,
+        });
+        const result = parseRepo(repo);
+        const cls = result.nodes.find((n) => n.name === "Dashboard");
+        expect(cls).toBeDefined();
+        expect(cls?.type).toBe("CLASS"); // NOT COMPONENT — one node per declaration
+        expect(cls?.metadata.isReactComponent).toBe(true);
+        expect(cls?.metadata.propsType).toBe("DashboardProps");
+        expect(cls?.metadata.stateType).toBe("DashboardState");
+        expect(result.nodes.some((n) => n.type === "COMPONENT" && n.name === "Dashboard")).toBe(false);
+        const render = result.nodes.find((n) => n.name === "Dashboard.render");
+        expect(render?.metadata.isReactLifecycle).toBe(true);
+        deleteFakeRepo(repo);
+    });
+    // 10. Multiple implements → implementsTypes
+    it("captures multiple implements clauses", () => {
+        const repo = createFakeRepo({
+            "src/multi.ts": `
+        interface A {}
+        interface B {}
+        export class Combined implements A, B {}
+      `,
+        });
+        const cls = nodesOf(repo, "CLASS").find((n) => n.name === "Combined");
+        expect(cls?.metadata.implementsTypes).toEqual(["A", "B"]);
+        deleteFakeRepo(repo);
+    });
+    // 11. extends local base → extendsType (raw text, generics kept)
+    it("captures the raw extends expression", () => {
+        const repo = createFakeRepo({
+            "src/inh.ts": `
+        export class Base {}
+        export class Child extends Base {}
+        export class GenericChild extends Base<string> {}
+      `,
+        });
+        const child = nodesOf(repo, "CLASS").find((n) => n.name === "Child");
+        expect(child?.metadata.extendsType).toBe("Base");
+        const generic = nodesOf(repo, "CLASS").find((n) => n.name === "GenericChild");
+        expect(generic?.metadata.extendsType).toBe("Base<string>");
+        deleteFakeRepo(repo);
+    });
+    // 12. Class inside a test file → testCases metadata only, zero child nodes
+    it("does not emit class/method nodes for test files", () => {
+        const repo = createFakeRepo({
+            "src/thing.test.ts": `
+        export class TestHelper { run() { return 1; } }
+        export function helper() { return new TestHelper().run(); }
+      `,
+        });
+        const result = parseRepo(repo);
+        expect(result.nodes.some((n) => n.type === "CLASS" || n.type === "METHOD")).toBe(false);
+        const testFile = result.nodes.find((n) => n.type === "TEST");
+        expect(testFile).toBeDefined();
+        expect(testFile?.metadata.testCases).toContain("TestHelper");
+        deleteFakeRepo(repo);
+    });
+    // 13. Class expression (const Foo = class {}) → skipped
+    it("skips class expressions", () => {
+        const repo = createFakeRepo({
+            "src/expr.ts": `
+        export const Foo = class {
+          bar() { return 1; }
+        };
+      `,
+        });
+        const result = parseRepo(repo);
+        expect(result.nodes.some((n) => n.type === "CLASS" && n.name === "Foo")).toBe(false);
+        expect(result.nodes.some((n) => n.type === "METHOD" && n.name === "Foo.bar")).toBe(false);
+        deleteFakeRepo(repo);
+    });
+    // 14-20. this-rewrite behavior
+    it("rewrites this.method() calls to Class.method", () => {
+        const repo = createFakeRepo({
+            "src/rewrite.ts": `
+        export class UserService {
+          save() { return 1; }
+          run() { return this.save(); }
+        }
+      `,
+        });
+        const run = nodesOf(repo, "METHOD").find((n) => n.name === "UserService.run");
+        expect(run?.metadata.calls).toContain("UserService.save");
+        expect(run?.metadata.calls).not.toContain("this.save");
+        deleteFakeRepo(repo);
+    });
+    it("does not rewrite this.obj.bar() when obj is a property", () => {
+        const repo = createFakeRepo({
+            "src/prop.ts": `
+        export class Adapter {
+          private nested = { emit: () => 1 };
+          go() { return this.nested.emit(); }
+        }
+      `,
+        });
+        const go = nodesOf(repo, "METHOD").find((n) => n.name === "Adapter.go");
+        expect(go?.metadata.calls).toContain("this.nested.emit"); // untouched
+        expect(go?.metadata.calls).not.toContain("Adapter.nested.emit");
+        deleteFakeRepo(repo);
+    });
+    it("leaves super.method() calls untouched", () => {
+        const repo = createFakeRepo({
+            "src/super.ts": `
+        export class Base { ping() { return 1; } }
+        export class Child extends Base {
+          call() { return super.ping(); }
+        }
+      `,
+        });
+        const call = nodesOf(repo, "METHOD").find((n) => n.name === "Child.call");
+        expect(call?.metadata.calls).toContain("super.ping");
+        expect(call?.metadata.calls).not.toContain("Child.ping");
+        deleteFakeRepo(repo);
+    });
+    it("rewrites this.method.bind(this) member expressions cleanly", () => {
+        const repo = createFakeRepo({
+            "src/bind.ts": `
+        export class Handler {
+          work() { return 1; }
+          setup() { return this.work.bind(this); }
+        }
+      `,
+        });
+        const setup = nodesOf(repo, "METHOD").find((n) => n.name === "Handler.setup");
+        expect(setup?.metadata.calls).toContain("Handler.work.bind");
+        deleteFakeRepo(repo);
+    });
+    it("rewrites this.foo() inside nested arrow functions", () => {
+        const repo = createFakeRepo({
+            "src/arrow.ts": `
+        export class Runner {
+          step() { return 1; }
+          all() { return [1].map(() => this.step()); }
+        }
+      `,
+        });
+        const all = nodesOf(repo, "METHOD").find((n) => n.name === "Runner.all");
+        expect(all?.metadata.calls).toContain("Runner.step");
+        deleteFakeRepo(repo);
+    });
+    it("rewrites this.foo() inside nested regular functions (heuristic)", () => {
+        const repo = createFakeRepo({
+            "src/fn.ts": `
+        export class Legacy {
+          step() { return 1; }
+          run() { return function () { return this.step(); }; }
+        }
+      `,
+        });
+        const run = nodesOf(repo, "METHOD").find((n) => n.name === "Legacy.run");
+        expect(run?.metadata.calls).toContain("Legacy.step"); // documented heuristic
+        deleteFakeRepo(repo);
+    });
+    it("rewrites this.bar() in static methods to Class.bar", () => {
+        const repo = createFakeRepo({
+            "src/stat.ts": `
+        export class Registry {
+          static lookup() { return 1; }
+          static init() { return this.lookup(); }
+        }
+      `,
+        });
+        const init = nodesOf(repo, "METHOD").find((n) => n.name === "Registry.init");
+        expect(init?.metadata.calls).toContain("Registry.lookup");
+        deleteFakeRepo(repo);
+    });
+    // Stats
+    it("reports classCount and methodCount in stats", () => {
+        const repo = createFakeRepo({
+            "src/stats.ts": `
+        export class Alpha { one() {} two() {} }
+        export class Beta { three() {} }
+      `,
+        });
+        const stats = parseRepo(repo).stats;
+        expect(stats.classCount).toBe(2);
+        expect(stats.methodCount).toBe(3);
+        deleteFakeRepo(repo);
+    });
+    // Node identity / wiring
+    it("normalizes class and method ids to relative paths with parentFile", () => {
+        const repo = createFakeRepo({
+            "src/ids.ts": `export class Widget { paint() {} }`,
+        });
+        const result = parseRepo(repo);
+        const cls = result.nodes.find((n) => n.name === "Widget");
+        const method = result.nodes.find((n) => n.name === "Widget.paint");
+        expect(cls?.id).toBe("src/ids.ts::Widget");
+        expect(cls?.parentFile).toBe("file::src/ids.ts");
+        expect(method?.id).toBe("src/ids.ts::Widget.paint");
+        expect(method?.parentFile).toBe("file::src/ids.ts");
+        expect(method?.filePath).toBe("src/ids.ts");
+        const fileNode = result.nodes.find((n) => n.type === "FILE" && n.filePath === "src/ids.ts");
+        expect(fileNode?.metadata.childNodeIds).toContain("src/ids.ts::Widget");
+        expect(fileNode?.metadata.childNodeIds).toContain("src/ids.ts::Widget.paint");
+        deleteFakeRepo(repo);
+    });
+});

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

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

package/dist/parser/extractors/classes.js

@@ -0,0 +1,241 @@
+// Extracts classes and their methods as CLASS / METHOD nodes.
+//
+// Previously, `class Foo {}` declarations (and React class components like
+// `class Dashboard extends React.Component`) were completely invisible to the
+// graph — the components extractor only sees functions, and the functions
+// extractor skips anything that isn't a function declaration or arrow.
+//
+// Conventions:
+//   - CLASS node id/name:        `Foo`            (file-scoped, like functions)
+//   - METHOD node id/name:       `Foo.bar`        (dotted — matches the Go
+//     extractor's `methodNodeID` and the objectMethods extractor, so
+//     `nodesByName` resolves `Foo.bar(...)` calls with zero extra plumbing)
+//   - `this.bar()` inside a method is rewritten to `Foo.bar(...)` at extraction
+//     time ONLY when `bar` is a method of the class (property access like
+//     `this.obj.bar()` is left alone). `super.x()` is never rewritten.
+//
+// Out of scope (deliberate): INTERFACE / ENUM / STRUCT nodes for JS/TS.
+import { SyntaxKind } from "ts-morph";
+import { detectFunctionDirective } from "../directives.js";
+import { extractFunctionCalls, extractHookCalls, extractApiCalls, hasErrorHandling, extractThrowStatements, } from "./functions.js";
+import { extractParams, extractReturnTypeAnnotation, extractBareTypeNames, extractReferencedInterfaces, } from "../typeUtils.js";
+// React lifecycle methods (incl. render) — flagged so consumers can tell
+// framework-registered callbacks apart from ordinary methods.
+const REACT_LIFECYCLE = new Set([
+    "render",
+    "componentDidMount",
+    "componentDidUpdate",
+    "componentWillUnmount",
+    "shouldComponentUpdate",
+    "getDerivedStateFromProps",
+    "getSnapshotBeforeUpdate",
+    "componentWillMount",
+    "componentWillReceiveProps",
+]);
+function makeId(filePath, name) {
+    return `${filePath}::${name}`;
+}
+// `React.Component<Props, State>` → `React.Component`; `Base<T>` → `Base`.
+// Used for extends-resolution (the detector only cares about the base name).
+export function stripGenerics(typeText) {
+    const lt = typeText.indexOf("<");
+    return (lt === -1 ? typeText : typeText.slice(0, lt)).trim();
+}
+// True when the extends expression is a React component base
+// (React.Component / React.PureComponent / Component / PureComponent).
+function isReactBase(extendsType) {
+    const base = stripGenerics(extendsType);
+    return /^(?:React\.)?(?:Pure)?Component$/.test(base);
+}
+// Pulls `Props` and `State` out of `React.Component<Props, State>` /
+// `Component<Props>` (top-level comma split — nested generics tolerated).
+function parseComponentGenerics(extendsType) {
+    const lt = extendsType.indexOf("<");
+    const gt = extendsType.lastIndexOf(">");
+    if (lt === -1 || gt === -1 || gt < lt)
+        return {};
+    const args = extendsType.slice(lt + 1, gt).split(",").map((a) => a.trim()).filter(Boolean);
+    if (args.length === 0)
+        return {};
+    const out = { propsType: args[0] };
+    if (args.length > 1)
+        out.stateType = args[1];
+    return out;
+}
+// Rewrites `this.foo(...)` call texts to `<ClassName>.foo(...)` so they match
+// the dotted METHOD node names in nodesByName. Only rewrites when the first
+// segment after `this.` is an actual method of the class — `this.obj.bar()`
+// (property access) and `super.x()` stay untouched. A leading `#` on the
+// method segment (private identifier `this.#foo()`) is stripped to match the
+// node name.
+function rewriteThisCalls(calls, className, methodNames) {
+    return calls.map((call) => {
+        if (!call.startsWith("this."))
+            return call;
+        const rest = call.slice("this.".length);
+        const firstSegment = rest.split(".")[0].replace(/^#/, "");
+        if (!methodNames.has(firstSegment))
+            return call;
+        return `${className}.${rest.replace(/^#/, "")}`;
+    });
+}
+function extractDecoratorNames(cls) {
+    if (typeof cls.getDecorators !== "function")
+        return [];
+    return cls.getDecorators().map((d) => (typeof d.getName === "function" ? d.getName() : d.getText()));
+}
+function isPrivateMethod(method, name) {
+    if (name.startsWith("#"))
+        return true;
+    return method.getModifiers().some((m) => m.getKind() === SyntaxKind.PrivateKeyword);
+}
+// Builds a METHOD node from any function-shaped class member.
+// methodNameSet — all method-ish names of the owning class, used by the
+// `this.` rewrite to distinguish methods from field/property access.
+function buildMethodNode(file, className, methodName, method, methodNameSet, fileDirective) {
+    const filePath = file.getFilePath();
+    const dotted = `${className}.${methodName}`;
+    const typedParams = extractParams(method);
+    const calls = extractFunctionCalls(method);
+    const hookCalls = extractHookCalls(method);
+    const apiCalls = extractApiCalls(method);
+    const isAsync = typeof method.isAsync === "function" && method.isAsync();
+    const hasErrors = hasErrorHandling(method);
+    const throws = extractThrowStatements(method);
+    const renderingBoundary = detectFunctionDirective(method.getBody?.()) ?? fileDirective;
+    const returnType = extractReturnTypeAnnotation(method);
+    const bareTypeNames = extractBareTypeNames([...typedParams.map((p) => p.type), returnType]);
+    const referencedTypes = extractReferencedInterfaces(file, bareTypeNames);
+    return {
+        id: makeId(filePath, dotted),
+        name: dotted,
+        type: "METHOD",
+        filePath,
+        startLine: method.getStartLineNumber(),
+        endLine: method.getEndLineNumber(),
+        rawCode: method.getText(),
+        metadata: {
+            className,
+            params: typedParams.map((p) => p.name),
+            parameters: typedParams,
+            returnType,
+            referencedTypes,
+            calls: rewriteThisCalls(calls, className, methodNameSet),
+            hookCalls,
+            apiCalls,
+            isAsync,
+            isStatic: typeof method.isStatic === "function" ? method.isStatic() : false,
+            isPrivate: isPrivateMethod(method, methodName),
+            isAbstract: typeof method.isAbstract === "function" ? method.isAbstract() : false,
+            isConstructor: methodName === "constructor",
+            isAccessor: undefined,
+            isReactLifecycle: REACT_LIFECYCLE.has(methodName),
+            hasErrorHandling: hasErrors,
+            throws,
+            lineCount: method.getEndLineNumber() - method.getStartLineNumber(),
+            ...(renderingBoundary !== null && { renderingBoundary }),
+        },
+    };
+}
+// All method-ish names of a class declaration (methods + constructor +
+// accessors) — used by the `this.` rewrite to distinguish methods from fields.
+function collectMethodNames(cls) {
+    const names = [];
+    for (const m of cls.getMethods?.() ?? []) {
+        const n = m.getName?.();
+        if (typeof n === "string")
+            names.push(n.startsWith("#") ? n.slice(1) : n);
+    }
+    for (const c of cls.getConstructors?.() ?? [])
+        names.push("constructor");
+    for (const a of [...(cls.getGetAccessors?.() ?? []), ...(cls.getSetAccessors?.() ?? [])]) {
+        const n = a.getName?.();
+        if (typeof n === "string")
+            names.push(n);
+    }
+    return names;
+}
+export function extractClasses(file, fileDirective = null) {
+    const nodes = [];
+    const filePath = file.getFilePath();
+    for (const cls of file.getClasses()) {
+        const name = cls.getName();
+        // Anonymous default-export classes (`export default class {}`) have no
+        // name to build an id from — skipped (documented).
+        if (!name)
+            continue;
+        const extendsClause = cls.getExtends();
+        const extendsType = extendsClause ? extendsClause.getText() : undefined;
+        const implementsTypes = cls.getImplements().map((t) => t.getExpression().getText());
+        const decorators = extractDecoratorNames(cls);
+        const isReactComponent = extendsType ? isReactBase(extendsType) : false;
+        const componentGenerics = isReactComponent && extendsType ? parseComponentGenerics(extendsType) : {};
+        const methodNames = collectMethodNames(cls);
+        const propertyNames = [...(cls.getProperties?.() ?? []), ...(cls.getStaticProperties?.() ?? [])]
+            .map((p) => p.getName?.())
+            .filter((n) => typeof n === "string");
+        const constructors = cls.getConstructors?.() ?? [];
+        const constructorParams = constructors[0]
+            ? constructors[0].getParameters().map((p) => p.getName())
+            : [];
+        const isExported = typeof cls.isExported === "function" ? cls.isExported() : false;
+        nodes.push({
+            id: makeId(filePath, name),
+            name,
+            type: "CLASS",
+            filePath,
+            startLine: cls.getStartLineNumber(),
+            endLine: cls.getEndLineNumber(),
+            rawCode: cls.getText(),
+            metadata: {
+                extendsType,
+                implementsTypes,
+                decorators,
+                isAbstract: typeof cls.isAbstract === "function" ? cls.isAbstract() : false,
+                isExported,
+                exportType: cls.isDefaultExport() ? "default" : isExported ? "named" : "none",
+                isReactComponent,
+                ...componentGenerics,
+                typeParams: cls.getTypeParameters().map((tp) => tp.getName()),
+                methodNames,
+                propertyNames,
+                constructorParams,
+                lineCount: cls.getEndLineNumber() - cls.getStartLineNumber(),
+            },
+        });
+        // ─── METHOD nodes ────────────────────────────────────────────────────
+        const methodNameSet = new Set(methodNames);
+        for (const m of cls.getMethods()) {
+            let methodName = m.getName();
+            if (typeof methodName !== "string" || methodName === "")
+                continue; // computed names
+            const isHashPrivate = methodName.startsWith("#");
+            if (isHashPrivate)
+                methodName = methodName.slice(1);
+            const node = buildMethodNode(file, name, methodName, m, methodNameSet, fileDirective);
+            if (isHashPrivate)
+                node.metadata.isPrivate = true;
+            nodes.push(node);
+        }
+        for (const c of cls.getConstructors()) {
+            nodes.push(buildMethodNode(file, name, "constructor", c, methodNameSet, fileDirective));
+        }
+        for (const acc of cls.getGetAccessors()) {
+            const accName = acc.getName();
+            if (typeof accName !== "string")
+                continue;
+            const node = buildMethodNode(file, name, accName, acc, methodNameSet, fileDirective);
+            node.metadata.isAccessor = "get";
+            nodes.push(node);
+        }
+        for (const acc of cls.getSetAccessors()) {
+            const accName = acc.getName();
+            if (typeof accName !== "string")
+                continue;
+            const node = buildMethodNode(file, name, accName, acc, methodNameSet, fileDirective);
+            node.metadata.isAccessor = "set";
+            nodes.push(node);
+        }
+    }
+    return nodes;
+}

package/dist/parser/index.d.ts

@@ -8,6 +8,8 @@ export interface ParserResult {
         hookCount: number;
         functionCount: number;
         storeCount: number;
+        classCount: number;
+        methodCount: number;
         skippedFiles: number;
     };
 }

package/dist/parser/index.js

@@ -6,6 +6,7 @@ import { extractHooks } from "./extractors/hooks.js";
 import { extractFunctions } from "./extractors/functions.js";
 import { extractStores } from "./extractors/stores.js";
 import { extractObjectMethods } from "./extractors/objectMethods.js";
+import { extractClasses } from "./extractors/classes.js";
 import { detectFileDirective } from "./directives.js";
 import { createHash } from "crypto";
 // Directories to skip entirely while walking
@@ -109,7 +110,8 @@ export function parseRepo(repoPath) {
             const functions = extractFunctions(file, fileDirective);
             const stores = extractStores(file);
             const objectMethods = extractObjectMethods(file, fileDirective);
-            const extracted = [...components, ...hooks, ...functions, ...stores, ...objectMethods];
+            const classes = extractClasses(file, fileDirective);
+            const extracted = [...components, ...hooks, ...functions, ...stores, ...objectMethods, ...classes];
             for (const node of extracted) {
                 // Normalize all extracted nodes to relative paths so every node in the
                 // graph uses the same coordinate system as the FILE nodes.
@@ -155,6 +157,8 @@ export function parseRepo(repoPath) {
     const hookCount = allNodes.filter((n) => n.type === "HOOK").length;
     const functionCount = allNodes.filter((n) => n.type === "FUNCTION").length;
     const storeCount = allNodes.filter((n) => n.type === "STATE_STORE").length;
+    const classCount = allNodes.filter((n) => n.type === "CLASS").length;
+    const methodCount = allNodes.filter((n) => n.type === "METHOD").length;
     return {
         nodes: allNodes,
         stats: {
@@ -164,6 +168,8 @@ export function parseRepo(repoPath) {
             hookCount,
             functionCount,
             storeCount,
+            classCount,
+            methodCount,
             skippedFiles,
         },
     };

package/dist/pipeline/index.d.ts

@@ -36,7 +36,7 @@ export interface PipelineResult {
     repoPath: string;
     analyzedAt: string;
     fingerprint: ProjectFingerprint;
-    routes: RouteNode[] | BackendRouteNode[];
+    routes: (RouteNode | BackendRouteNode)[];
     nodes: CodeNode[];
     edges: CodeEdge[];
     allNodes: CodeNode[];
@@ -46,5 +46,6 @@ export interface PipelineResult {
     isGithubRepo: boolean;
     gitInfo: GitInfo;
 }
+export declare function routesToCodeNodes(routes: (RouteNode | BackendRouteNode)[], repoPath: string): CodeNode[];
 export declare function analyzePipeline(repoPath: string, isGithubRepo: boolean, options?: PipelineOptions): Promise<PipelineResult>;
 export declare function refilterPipeline(stored: PipelineResult, thresholds: FilterThresholds): Pick<PipelineResult, "nodes" | "edges" | "stats">;