driftdetect-core 0.1.0

package/dist/analyzers/ast-analyzer.d.ts

@@ -0,0 +1,251 @@
+/**
+ * AST Analyzer - AST pattern analysis
+ *
+ * Performs AST pattern matching, subtree comparison, and provides
+ * traversal utilities for analyzing code structure.
+ *
+ * @requirements 3.5 - Parser SHALL provide a unified AST query interface across all languages
+ */
+import type { AST, ASTNode, Position } from '../parsers/types.js';
+import type { ASTAnalysisResult, ASTStats, SourceLocation } from './types.js';
+/**
+ * Pattern definition for AST matching
+ */
+export interface ASTPattern {
+    /** Node type to match (e.g., 'FunctionDeclaration', 'ClassDeclaration') */
+    type?: string;
+    /** Text content to match (exact or regex) */
+    text?: string | RegExp;
+    /** Whether text matching should be exact */
+    exactText?: boolean;
+    /** Child patterns to match */
+    children?: ASTPattern[];
+    /** Minimum number of children required */
+    minChildren?: number;
+    /** Maximum number of children allowed */
+    maxChildren?: number;
+    /** Custom predicate for additional matching logic */
+    predicate?: (node: ASTNode) => boolean;
+    /** Whether to match any descendant (not just direct children) */
+    matchDescendants?: boolean;
+    /** Capture name for extracting matched nodes */
+    capture?: string;
+}
+/**
+ * Options for pattern matching
+ */
+export interface PatternMatchOptions {
+    /** Maximum number of matches to return */
+    limit?: number;
+    /** Whether to include nested matches */
+    includeNested?: boolean;
+    /** Starting position for the search */
+    startPosition?: Position;
+    /** Ending position for the search */
+    endPosition?: Position;
+    /** Minimum confidence threshold for matches */
+    minConfidence?: number;
+}
+/**
+ * Result of a pattern match with captured nodes
+ */
+export interface PatternMatchResult {
+    /** The matched node */
+    node: ASTNode;
+    /** Confidence score (0-1) */
+    confidence: number;
+    /** Captured nodes by name */
+    captures: Map<string, ASTNode>;
+    /** Location in source */
+    location: SourceLocation;
+}
+/**
+ * Options for subtree comparison
+ */
+export interface SubtreeCompareOptions {
+    /** Whether to ignore node text differences */
+    ignoreText?: boolean;
+    /** Whether to ignore position differences */
+    ignorePosition?: boolean;
+    /** Node types to ignore during comparison */
+    ignoreTypes?: string[];
+    /** Maximum depth to compare */
+    maxDepth?: number;
+    /** Similarity threshold (0-1) for considering subtrees similar */
+    similarityThreshold?: number;
+}
+/**
+ * Result of subtree comparison
+ */
+export interface SubtreeCompareResult {
+    /** Whether the subtrees are structurally identical */
+    isIdentical: boolean;
+    /** Similarity score (0-1) */
+    similarity: number;
+    /** Differences found between subtrees */
+    differences: SubtreeDifference[];
+    /** Statistics about the comparison */
+    stats: {
+        nodesCompared: number;
+        matchingNodes: number;
+        differentNodes: number;
+    };
+}
+/**
+ * A difference found between two subtrees
+ */
+export interface SubtreeDifference {
+    /** Type of difference */
+    type: 'type_mismatch' | 'text_mismatch' | 'children_count' | 'missing_child' | 'extra_child';
+    /** Path to the difference in the first subtree */
+    path1: number[];
+    /** Path to the difference in the second subtree */
+    path2: number[];
+    /** Description of the difference */
+    description: string;
+    /** Node from first subtree (if applicable) */
+    node1?: ASTNode;
+    /** Node from second subtree (if applicable) */
+    node2?: ASTNode;
+}
+/**
+ * Visitor function for AST traversal
+ */
+export type ASTVisitorFn = (node: ASTNode, parent: ASTNode | null, depth: number, path: number[]) => boolean | void;
+/**
+ * AST Analyzer class for pattern matching and subtree comparison.
+ *
+ * Provides a unified interface for analyzing AST structures across
+ * all supported languages.
+ *
+ * @requirements 3.5 - Unified AST query interface across all languages
+ */
+export declare class ASTAnalyzer {
+    /**
+     * Find all nodes matching a pattern in the AST.
+     *
+     * @param ast - The AST to search
+     * @param pattern - The pattern to match
+     * @param options - Matching options
+     * @returns Array of pattern match results
+     */
+    findPattern(ast: AST, pattern: ASTPattern, options?: PatternMatchOptions): PatternMatchResult[];
+    /**
+     * Compare two AST subtrees for similarity.
+     *
+     * @param node1 - First subtree root
+     * @param node2 - Second subtree root
+     * @param options - Comparison options
+     * @returns Comparison result with similarity score and differences
+     */
+    compareSubtrees(node1: ASTNode, node2: ASTNode, options?: SubtreeCompareOptions): SubtreeCompareResult;
+    /**
+     * Get statistics about an AST.
+     *
+     * @param ast - The AST to analyze
+     * @returns Statistics about the AST structure
+     */
+    getStats(ast: AST): ASTStats;
+    /**
+     * Traverse the AST depth-first, calling the visitor for each node.
+     *
+     * @param ast - The AST to traverse
+     * @param visitor - Function called for each node. Return false to stop traversal of subtree.
+     */
+    traverse(ast: AST, visitor: ASTVisitorFn): void;
+    /**
+     * Find all nodes of a specific type in the AST.
+     *
+     * @param ast - The AST to search
+     * @param nodeType - The type of node to find
+     * @returns Array of matching nodes
+     */
+    findNodesByType(ast: AST, nodeType: string): ASTNode[];
+    /**
+     * Find the first node of a specific type in the AST.
+     *
+     * @param ast - The AST to search
+     * @param nodeType - The type of node to find
+     * @returns The first matching node, or null if not found
+     */
+    findFirstNodeByType(ast: AST, nodeType: string): ASTNode | null;
+    /**
+     * Find the node at a specific position in the source.
+     *
+     * @param ast - The AST to search
+     * @param position - The position to find
+     * @returns The most specific node at that position, or null
+     */
+    findNodeAtPosition(ast: AST, position: Position): ASTNode | null;
+    /**
+     * Get all descendants of a node.
+     *
+     * @param node - The node to get descendants of
+     * @returns Array of all descendant nodes
+     */
+    getDescendants(node: ASTNode): ASTNode[];
+    /**
+     * Get the depth of a node in the AST.
+     *
+     * @param ast - The AST containing the node
+     * @param targetNode - The node to get depth for
+     * @returns The depth (0 for root), or -1 if not found
+     */
+    getNodeDepth(ast: AST, targetNode: ASTNode): number;
+    /**
+     * Get the parent chain from root to a specific node.
+     *
+     * @param ast - The AST to search
+     * @param targetNode - The node to find parents for
+     * @returns Array of parent nodes from root to immediate parent
+     */
+    getParentChain(ast: AST, targetNode: ASTNode): ASTNode[];
+    /**
+     * Check if a node is a leaf node (has no children).
+     *
+     * @param node - The node to check
+     * @returns true if the node has no children
+     */
+    isLeafNode(node: ASTNode): boolean;
+    /**
+     * Analyze an AST and return analysis results.
+     *
+     * @param ast - The AST to analyze
+     * @param patterns - Patterns to search for
+     * @returns Analysis result with matches and statistics
+     */
+    analyze(ast: AST, patterns: Map<string, ASTPattern>): ASTAnalysisResult;
+    /**
+     * Internal recursive traversal helper.
+     */
+    private traverseNode;
+    /**
+     * Match a pattern against a node and return confidence score.
+     */
+    private matchPattern;
+    /**
+     * Match text against a pattern (string or regex).
+     */
+    private matchText;
+    /**
+     * Match child patterns against node children.
+     */
+    private matchChildPatterns;
+    /**
+     * Compare two nodes recursively.
+     */
+    private compareNodes;
+    /**
+     * Check if a position is within a range.
+     */
+    private positionInRange;
+    /**
+     * Check if position a is after position b.
+     */
+    private isAfterPosition;
+    /**
+     * Check if position a is before position b.
+     */
+    private isBeforePosition;
+}
+//# sourceMappingURL=ast-analyzer.d.ts.map

package/dist/analyzers/ast-analyzer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ast-analyzer.d.ts","sourceRoot":"","sources":["../../src/analyzers/ast-analyzer.ts"],"names":[],"mappings":"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"}