@nithin554/code-crawler 0.1.36 → 0.1.38

package/dist/graph/queries.d.ts

@@ -17,11 +17,22 @@ export interface SymbolRef {
 }
 export interface CallerInfo {
     caller: SymbolRef;
-    /** Properties of the CALLS edge (call site line, resolution, confidence). */
+    /** Properties of the call edge (call site line, resolution, confidence). */
     callSiteLine?: number;
     resolved?: boolean;
+    /** Which edge kind connected the caller: CALLS | DYNAMIC_DISPATCH | ADVISES. */
+    edgeKind?: EdgeKind;
 }
-export interface CallerQueryOptions {
+/** Options controlling which dynamic edges a traversal follows. */
+export interface DynamicEdgeOptions {
+    /** Follow DYNAMIC_DISPATCH edges (virtual/interface call targets). */
+    includeDynamic?: boolean;
+    /** Follow ADVISES edges (aspect advice -> advised method). */
+    includeAdvice?: boolean;
+}
+/** Edge kinds a traversal should follow, ordered from most to least certain. */
+export declare function traversalEdgeKinds(opts?: DynamicEdgeOptions): EdgeKind[];
+export interface CallerQueryOptions extends DynamicEdgeOptions {
     /** Include transitive callers (whole call graph above). Default true. */
     transitive?: boolean;
     /** Max depth for transitive traversal. Bounded by config maxDepth. */
@@ -39,9 +50,10 @@ export declare function getCallers(store: GraphStore, symbol: string, opts?: Cal
         caller: SymbolRef;
         depth: number;
         callSiteLine?: number;
+        edgeKind: EdgeKind;
     }[];
 } | null;
-export interface CalleeQueryOptions {
+export interface CalleeQueryOptions extends DynamicEdgeOptions {
     /** Include transitive callees (whole call graph below). Default true. */
     transitive?: boolean;
     maxDepth?: number;
@@ -56,6 +68,7 @@ export declare function getCallees(store: GraphStore, symbol: string, opts?: Cal
         callee: SymbolRef;
         depth: number;
         callSiteLine?: number;
+        edgeKind: EdgeKind;
     }[];
 } | null;
 export interface PathEntry {
@@ -65,19 +78,40 @@ export interface PathEntry {
     edges: {
         source: string;
         target: string;
+        kind?: EdgeKind;
         callSiteLine?: number;
         resolved?: boolean;
     }[];
 }
-export interface TracePathOptions {
+export interface TracePathOptions extends DynamicEdgeOptions {
     maxDepth?: number;
     limit?: number;
 }
 /**
- * Find up to `limit` static call paths between two symbols.
- * BFS over CALLS edges so the shortest paths come first.
+ * Find up to `limit` call paths between two symbols.
+ * BFS over the selected edge kinds so the shortest paths come first.
  */
 export declare function tracePath(store: GraphStore, from: string, to: string, opts?: TracePathOptions): PathEntry[] | null;
+export interface ExecutionTraceOptions extends DynamicEdgeOptions {
+    maxDepth?: number;
+    limit?: number;
+}
+export interface ExecutionStep {
+    symbol: SymbolRef;
+    depth: number;
+    /** How the runtime reached this symbol. INTERCEPT marks woven advice. */
+    via?: EdgeKind | "INTERCEPT";
+    callSiteLine?: number;
+}
+/**
+ * Dynamic execution trace: follows static + virtual dispatch edges and weaves
+ * in aspect advice. When a call reaches an advised method, the advice method
+ * is visited first (an `INTERCEPT` edge), then the method itself.
+ */
+export declare function traceExecution(store: GraphStore, symbol: string, opts?: ExecutionTraceOptions): {
+    root: SymbolRef;
+    steps: ExecutionStep[];
+} | null;
 export interface SubgraphOptions {
     radius?: number;
     edgeKinds?: EdgeKind[];
@@ -109,3 +143,99 @@ export interface SearchOptions {
 export declare function searchSymbols(store: GraphStore, query: string, opts?: SearchOptions): SymbolRef[];
 /** Suggest similar symbols when an exact lookup fails. */
 export declare function suggestSymbols(store: GraphStore, symbol: string, limit?: number): SymbolRef[];
+export interface ImplementationResult {
+    target: SymbolRef;
+    implementations: {
+        type: SymbolRef;
+        depth: number;
+        via: "EXTENDS" | "IMPLEMENTS";
+    }[];
+}
+/**
+ * Find every type that implements/extends a given interface or superclass,
+ * directly or transitively.
+ */
+export declare function findImplementations(store: GraphStore, symbol: string, opts?: {
+    maxDepth?: number;
+    limit?: number;
+}): ImplementationResult | null;
+export interface AdviceDetail {
+    method: SymbolRef;
+    adviceKind?: string;
+    pointcut?: string;
+    advised: SymbolRef[];
+}
+export interface AspectDetail {
+    aspect: SymbolRef;
+    advice: AdviceDetail[];
+}
+/** List aspects, their advice methods, and the methods each advice intercepts. */
+export declare function getAspects(store: GraphStore, opts?: {
+    limit?: number;
+}): AspectDetail[];
+export interface DecoratorInfo {
+    name: string;
+    fqn?: string;
+    decorator: boolean;
+    line?: number;
+    arguments: string[];
+}
+export interface SymbolDecorators {
+    symbol: SymbolRef;
+    decorators: DecoratorInfo[];
+    members: {
+        symbol: SymbolRef;
+        decorators: DecoratorInfo[];
+    }[];
+}
+/**
+ * Decorators/annotations applied to a symbol, optionally including the
+ * annotations on its declared members (methods, constructors, fields).
+ */
+export declare function getDecorators(store: GraphStore, symbol: string, opts?: {
+    includeMembers?: boolean;
+}): SymbolDecorators | null;
+export interface AnnotatedSymbol {
+    symbol: SymbolRef;
+    annotation: {
+        name: string;
+        fqn?: string;
+    };
+    line?: number;
+    arguments: string[];
+}
+/**
+ * Find every symbol annotated/decorated with the given annotation. Accepts a
+ * simple name (`Transactional`), a node id (`@Transactional`) or an FQN.
+ */
+export declare function findAnnotated(store: GraphStore, annotation: string, opts?: {
+    kind?: NodeKind;
+    limit?: number;
+}): AnnotatedSymbol[];
+export interface Hotspot {
+    symbol: SymbolRef;
+    fanIn: number;
+    fanOut: number;
+    adviceCount: number;
+}
+/** Rank callable symbols by incoming/outgoing call volume. */
+export declare function hotspots(store: GraphStore, opts?: {
+    limit?: number;
+    minFanIn?: number;
+    includeDynamic?: boolean;
+}): Hotspot[];
+export interface DeadSymbol {
+    symbol: SymbolRef;
+    reason: string;
+}
+/**
+ * Find methods/constructors with no incoming call, dispatch or advice edges.
+ * Heuristic: framework entry points, tests and constructors are excluded by
+ * default because they are invoked reflectively or by containers.
+ */
+export declare function deadCode(store: GraphStore, opts?: {
+    limit?: number;
+    includeConstructors?: boolean;
+    includeTests?: boolean;
+    includeDynamic?: boolean;
+}): DeadSymbol[];