Loads a JavaScript/TypeScript project directory for deterministic analysis (ts-morph). Detects Vue, Nuxt, Angular, Express, Fastify or Node.

Lists the currently loaded projects.

Rescans the file tree and incrementally syncs the ts-morph project: only re-reads files whose size or mtime changed.

Unloads a project from memory.

Executive summary of a loaded project: framework, files, functions, types, variables and capabilities.

Detects the framework of the loaded project (Vue, Nuxt, Angular, Express, Fastify, Node, plain).

Returns the content of a project file. It is resolved by matching a path suffix.

Searches for text in the code of all project files (case-insensitive).

Lists the TS/JS files of the project with their line count. Optionally filter by extension.

Lists all functions and class methods, with signature, file and line.

Lists interfaces, type aliases, enums and classes with their members.

Lists module-level (top-level) variables with type and line.

Local call graph: shows which functions call which functions.

Finds all references to a symbol in the project.

Data-flow cross-reference of a variable: where it is defined, read and written (semantic DEFINITION/WRITE/READ classification via ts-morph).

Finds the calls to a function (invocations with parentheses).

Metrics per function/method: cyclomatic complexity, body lines and parameters. Optional threshold filters.

Functions/methods with high cyclomatic complexity (technical-debt heuristic), grouped by file.

Functions/methods with a long body (technical-debt heuristic).

Real type errors of the project: TypeChecker diagnostics (getPreEmitDiagnostics via ts-morph), grouped by file.

Interfaces with methods that no class explicitly implements (heuristic: TS is structural).

any usages in the project (type-debt heuristic): : any annotations, as any, <any>, parameters and returns typed as any. Grouped by file.

Resolves a symbol to its definition: function, type alias, interface, class or enum.

Checks which classes implement an interface or extend another (inheritance).

Hierarchy of a type: what it extends/implements and who extends/implements it.

Inspects a function or method (class.method): signature, parameters, doc, body.

Inspects a class: decorators, extends/implements, fields, methods, constructor.

Detects async calls (fetch, fs.*, exec, etc.) without await or .catch — possible unhandled error.

Module-level (top-level) variables that are not used in the rest of the file.

Functions and private methods that are not referenced locally (dead code).

Lists the .vue files of a project.

Analyzes a .vue component: props, emits, slots, composables, reactive state, provide/inject.

Analyzes which script variables are used in the of a .vue component.

Cross-file provide/inject graph: which keys each file provides and which are injected, with exported-constant resolution and orphan keys (inject without provide).

Declared reactive state (ref/reactive/computed/shallowRef) not used in the template or the rest of the script (heuristic).

Identifiers used in the that do not resolve to any Vue binding/local/builtin (heuristic: possible typo or undeclared variable).

definePageMeta per page: layout, middleware, title, validate, pageTransition and name.

Routes generated from pages/ (with dynamic params and catch-all) and from server/api.

Lists the auto-imported composables in composables/ and utils/.

Routes of the server/ API (server/api, server/routes) with HTTP method.

Shows the auto-imports available in Nuxt (Vue composables + Nuxt utilities).

Shows the content of nuxt.config.ts.

Lists Nuxt plugins and middleware.

React components: .tsx/.jsx files with JSX, their exports and used hooks.

Next.js routes: app router (app/**/page.tsx) and pages router (pages/*.tsx).

In-depth analysis of a React component: typed props, hooks with arguments, consumed contexts, custom hooks, early returns and memo/forwardRef. Deterministic (ts-morph).

Inventory of useEffect/useMemo/useCallback with their dependency array (heuristic: marks deps used in the callback but missing from the array).

API routes of the Next app router: route.ts with HTTP methods (GET/POST/...) and dynamic params, plus middleware.ts with its matcher.

React contexts cross-file: createContext, providers (<X.Provider>) and consumers (useContext).

State inventory per component: useState/useReducer/useRef/useSyncExternalStore with initial value and bindings (setters/dispatch).

useEffect that registers listeners/timers/subscriptions (addEventListener/setInterval/.subscribe) without cleanup (return) (heuristic).

Data fetching/ISR/cache in the Next app router: revalidate, generateStaticParams, generateMetadata, dynamicParams, fetch with next.revalidate/tags and use client/server directives.

Components with non-primitive props (objects/arrays/functions) without memo() and JSX with new values per render (performance heuristic).

In-depth analysis of a Svelte component: props, reactivity ($:), stores (writable/readable/derived), context (setContext/getContext), lifecycle, bindings, snippets and dispatched events.

SvelteKit routes by directory convention (src/routes): +page.svelte, +page.server.ts (load/actions), +layout, +server.ts (API) and +error.

Svelte components: .svelte files with props (export let), stores and dispatched events.

Lists the .tsx/.jsx/.svelte files of the project with their line count.

onMount that registers listeners/timers (addEventListener/setInterval/subscribe) without cleanup in onDestroy (heuristic).

Stores (writable/readable/derived) declared/exported but not used in any template or script (heuristic).

hooks.server.ts: handle (with sequence()), handleError and handleFetch with their structure.

load and actions of +page.server.ts/+layout.server.ts per route, with details (throw error/fail/redirect/params).

Lists Angular components (@Component) with selector and standalone.

Analyzes a component: @Input/@Output, providers, constructor DI, lifecycle hooks.

Template binding analysis with @angular/compiler: inputs, outputs, interpolations, pipes, structural directives, and references to identifiers without a class member.

DI dependency graph: @Injectable services and who consumes them.

Routes defined with Routes/RouterModule (path -> component/loadChildren).

Lists NgModules.

Lists @Injectable services.

NgModules graph: declarations, imports and providers per module.

Route guards and resolvers: which guards/resolvers each route uses (canActivate/canActivateChild/canActivateFn/canDeactivate/canLoad/canMatch/resolve) and where they are defined (classes or functions).

Component inventory: standalone (with their composition imports) vs non-standalone (NgModule-dependent). Angular 19+: standalone by default.

Change detection strategies per component (heuristic): without ChangeDetectionStrategy.OnPush, manual CD (detectChanges/markForCheck/detach/reattach) and components with OnPush.

Uncleaned subscriptions (heuristic): subscribe() in components/directives/services without ngOnDestroy/unsubscribe/takeUntil/async pipe in the class (comments are ignored).

Detects HTTP endpoints: Express (app/router.get/post/...), Fastify, Koa.

Call chain of an endpoint: handler → service → repo, validation (zod/joi/validate*), auth middleware and next(err). Resolves mounted routers (app.use("/prefix", router)).

Express sub-routers (express.Router()) and their mounting (app.use), global middleware order and error-handlers (4 args).

Usage of native Node modules (node:fs, path, etc.) with imports/require.

Project entry points: package.json scripts, main, listen(), shebang.

Async patterns: await/Promise, .catch, EventEmitter, timers.

Environment variables read with process.env in the project (environment dependencies).

EventEmitter listeners registered without their cleanup pair in the same scope (heuristic).

fs.*Sync inside Express handlers or async functions: blocks the event loop (heuristic).

Streams/connections/http.request without close/end/destroy in the same scope (heuristic).

Deprecated Node APIs: new Buffer, url.parse, util.is*, createCipher, require.extensions (heuristic).

Dependency graph between project modules: relative imports/requires resolved to files, with cycle detection and modules without importers.

Maps production modules (src/) to their tests (.test./.spec.) by imports; also lists src/ modules without tests.

XSS vectors (heuristic): v-html (Vue), {@html} (Svelte), dangerouslySetInnerHTML (React), innerHTML/insertAdjacentHTML/document.write (DOM).

Possible SQL injection (heuristic): query/execute calls with interpolated template literal or string concatenation.

Usage of eval / new Function / Function() (heuristic): dynamic code execution.

Possible command injection (heuristic): exec/execSync/spawn with variable interpolation.

Hardcoded secrets (heuristic): keys/passwords/tokens with literal values, URLs with credentials, private keys and AWS keys.

Insecure HTTP (heuristic): http:// (not https), WebSocket ws:// and cookies without explicit Secure/HttpOnly.

Silent catches (heuristic): empty catch blocks, console-only, or those that discard the error without binding or re-throw.

Listeners and timers without cleanup (heuristic): addEventListener/setInterval without removeEventListener/clearInterval in the same scope.

Duplicated code blocks (heuristic): sequences of identical lines in ≥2 functions (copy-paste).

TODO / FIXME / HACK / XXX markers in comments (pending debt).

package.json dependencies that are not imported in any file (heuristic).

Type suppressors: @ts-ignore / @ts-nocheck / @ts-expect-error (type debt).

Magic numbers (heuristic): numeric literals that are not 0/1 outside named constants (config).

Non-null assertions expr! (type-debt heuristic): assume the value is not null/undefined without checking it.