analyzer

type APTEDAnalyzer struct {
	// contains filtered or unexported fields
}

type ASTFeatureExtractor struct {
	// contains filtered or unexported fields
}

type BasicBlock struct {
	// ID is the unique identifier for this block
	ID string

	// Statements contains the AST nodes in this block
	Statements []*parser.Node

	// Predecessors are blocks that can flow into this block
	Predecessors []*Edge

	// Successors are blocks that this block can flow to
	Successors []*Edge

	// Label is an optional human-readable label
	Label string

	// IsEntry indicates if this is an entry block
	IsEntry bool

	// IsExit indicates if this is an exit block
	IsExit bool
}

type CBOAnalyzer struct {
	// contains filtered or unexported fields
}

type CBOAnalyzerConfig struct {
	// IncludeBuiltins includes Node.js builtin modules in coupling count
	IncludeBuiltins bool

	// IncludeTypeImports includes TypeScript type imports in coupling count
	IncludeTypeImports bool

	// LowThreshold is the CBO threshold for low risk (CBO <= LowThreshold)
	LowThreshold int

	// MediumThreshold is the CBO threshold for medium risk (LowThreshold < CBO <= MediumThreshold)
	MediumThreshold int
}

type CFG struct {
	// Entry is the entry point of the graph
	Entry *BasicBlock

	// Exit is the exit point of the graph
	Exit *BasicBlock

	// Blocks contains all blocks in the graph, indexed by ID
	Blocks map[string]*BasicBlock

	// Name is the name of the CFG (e.g., function name)
	Name string

	// FunctionNode is the original AST node for the function
	FunctionNode *parser.Node
	// contains filtered or unexported fields
}

type CFGBuilder struct {
	// contains filtered or unexported fields
}

type CFGVisitor interface {
	// VisitBlock is called for each basic block
	// Returns false to stop traversal
	VisitBlock(block *BasicBlock) bool

	// VisitEdge is called for each edge
	// Returns false to stop traversal
	VisitEdge(edge *Edge) bool
}

type CentroidGrouping struct {
	// contains filtered or unexported fields
}

type CircularDependencyDetector struct {
	// contains filtered or unexported fields
}

type ClassDependencies struct {
	// Unique modules/classes this class depends on
	DependentClasses map[string]bool

	// Breakdown by type
	ImportDependencies          map[string]bool
	InstantiationDependencies   map[string]bool
	TypeHintDependencies        map[string]bool
	AttributeAccessDependencies map[string]bool
}

type CloneDetector struct {
	// contains filtered or unexported fields
}

type CloneDetectorConfig struct {
	// Minimum number of lines for a code fragment to be considered
	MinLines int

	// Minimum number of AST nodes for a code fragment
	MinNodes int

	// Similarity thresholds for different clone types
	Type1Threshold float64
	Type2Threshold float64
	Type3Threshold float64
	Type4Threshold float64

	// Maximum edit distance allowed
	MaxEditDistance float64

	// Whether to ignore differences in literals
	IgnoreLiterals bool

	// Whether to ignore differences in identifiers
	IgnoreIdentifiers bool

	// Cost model to use for APTED
	CostModelType string // "default", "javascript", "weighted"

	// Performance tuning parameters
	MaxClonePairs      int // Maximum pairs to keep in memory
	BatchSizeThreshold int // Minimum fragments to trigger batching
	BatchSizeLarge     int // Batch size for normal projects
	BatchSizeSmall     int // Batch size for large projects
	LargeProjectSize   int // Fragment count threshold for large projects

	// Grouping configuration
	GroupingMode      GroupingMode // Default: GroupingModeConnected
	GroupingThreshold float64      // Default: Type3Threshold
	KCoreK            int          // Default: 2

	// LSH Configuration (optional, opt-in)
	UseLSH                 bool    // Enable LSH acceleration
	LSHSimilarityThreshold float64 // Candidate threshold using MinHash similarity
	LSHBands               int     // Number of LSH bands (default: 32)
	LSHRows                int     // Rows per band (default: 4)
	LSHMinHashCount        int     // Number of MinHash functions (default: 128)
}

type ClusterResult struct {
	Groups    [][]int     // Groups of tree indices that are similar
	Distances [][]float64 // Distance matrix between all trees
	Threshold float64     // Similarity threshold used
}

type CodeFragment struct {
	Location   *CodeLocation
	ASTNode    *parser.Node
	TreeNode   *TreeNode
	Content    string // Original source code content
	Hash       string // Hash for quick comparison
	Size       int    // Number of AST nodes
	LineCount  int    // Number of source lines
	Complexity int    // Cyclomatic complexity (if applicable)
}

type CodeLocation struct {
	FilePath  string
	StartLine int
	EndLine   int
	StartCol  int
	EndCol    int
}

type CompleteLinkageGrouping struct {
	// contains filtered or unexported fields
}

type ComplexityAnalyzer struct {
	// contains filtered or unexported fields
}

type ComplexityResult struct {
	// McCabe cyclomatic complexity
	Complexity int

	// Raw CFG metrics
	Edges               int
	Nodes               int
	ConnectedComponents int

	// Function/method information
	FunctionName string
	StartLine    int
	StartCol     int
	EndLine      int

	// Nesting depth
	NestingDepth int

	// Decision points breakdown
	IfStatements      int
	LoopStatements    int
	ExceptionHandlers int
	SwitchCases       int
	LogicalOperators  int // JavaScript-specific: &&, ||, ??
	TernaryOperators  int // JavaScript-specific: ? :

	// Risk assessment based on complexity thresholds
	RiskLevel string // "low", "medium", "high"
}

type ConnectedGrouping struct {
	// contains filtered or unexported fields
}

type CostModel interface {
	// Insert returns the cost of inserting a node
	Insert(node *TreeNode) float64

	// Delete returns the cost of deleting a node
	Delete(node *TreeNode) float64

	// Rename returns the cost of renaming node1 to node2
	Rename(node1, node2 *TreeNode) float64
}

type CouplingMetricsCalculator struct {
	// contains filtered or unexported fields
}

type CouplingMetricsConfig struct {
	// InstabilityHighThreshold defines the threshold for high instability (default: 0.8)
	InstabilityHighThreshold float64

	// InstabilityLowThreshold defines the threshold for low instability (default: 0.2)
	InstabilityLowThreshold float64

	// DistanceThreshold defines the threshold for main sequence deviation (default: 0.3)
	DistanceThreshold float64

	// CouplingHighThreshold defines the threshold for high coupling risk (default: 10)
	CouplingHighThreshold int

	// CouplingMediumThreshold defines the threshold for medium coupling risk (default: 5)
	CouplingMediumThreshold int
}

type DeadCodeDetector struct {
	// contains filtered or unexported fields
}

type DeadCodeFinding struct {
	// Function information
	FunctionName string `json:"function_name"`
	FilePath     string `json:"file_path"`

	// Location information
	StartLine int `json:"start_line"`
	EndLine   int `json:"end_line"`

	// Dead code details
	BlockID     string         `json:"block_id"`
	Code        string         `json:"code"`
	Reason      DeadCodeReason `json:"reason"`
	Severity    SeverityLevel  `json:"severity"`
	Description string         `json:"description"`

	// Context information
	Context []string `json:"context,omitempty"`
}

type DeadCodeReason string

type DeadCodeResult struct {
	// Function information
	FunctionName string `json:"function_name"`
	FilePath     string `json:"file_path"`

	// Analysis results
	Findings       []*DeadCodeFinding `json:"findings"`
	TotalBlocks    int                `json:"total_blocks"`
	DeadBlocks     int                `json:"dead_blocks"`
	ReachableRatio float64            `json:"reachable_ratio"`

	// Performance metrics
	AnalysisTime time.Duration `json:"analysis_time"`
}

type DefaultCostModel struct{}

type DependencyGraphBuilder struct {
	// contains filtered or unexported fields
}

type DependencyGraphBuilderConfig struct {
	// IncludeExternal includes external modules (node_modules) in the graph
	IncludeExternal bool

	// IncludeTypeImports includes TypeScript type-only imports
	IncludeTypeImports bool

	// ProjectRoot is the root directory for path normalization
	ProjectRoot string
}

type Edge struct {
	From *BasicBlock
	To   *BasicBlock
	Type EdgeType
}

type EdgeType int

type FeatureExtractor interface {
	ExtractFeatures(ast *TreeNode) ([]string, error)
	ExtractSubtreeHashes(ast *TreeNode, maxHeight int) []string
	ExtractNodeSequences(ast *TreeNode, k int) []string
}

type GroupingConfig struct {
	Mode           GroupingMode
	Threshold      float64
	KCoreK         int
	Type1Threshold float64
	Type2Threshold float64
	Type3Threshold float64
	Type4Threshold float64
}

type GroupingMode string

type GroupingStrategy interface {
	// GroupClones groups the given clone pairs into clone groups.
	GroupClones(pairs []*domain.ClonePair) []*domain.CloneGroup
	// GetName returns the strategy name.
	GetName() string
}

type HashFunc func(uint64) uint64

type JavaScriptCostModel struct {
	// Base costs for different operations
	BaseInsertCost float64
	BaseDeleteCost float64
	BaseRenameCost float64

	// Whether to ignore differences in literal values
	IgnoreLiterals bool

	// Whether to ignore differences in identifier names
	IgnoreIdentifiers bool
}

type KCoreGrouping struct {
	// contains filtered or unexported fields
}

type LSHIndex struct {
	// contains filtered or unexported fields
}

type MinHashSignature struct {
	// contains filtered or unexported fields
}

type MinHasher struct {
	// contains filtered or unexported fields
}

type ModuleAnalyzer struct {
	// contains filtered or unexported fields
}

type ModuleAnalyzerConfig struct {
	// IncludeBuiltins includes Node.js builtin modules in analysis
	IncludeBuiltins bool

	// ResolveRelative enables resolution of relative import paths
	ResolveRelative bool

	// IncludeTypeImports includes TypeScript type imports
	IncludeTypeImports bool

	// AliasPatterns are path alias patterns to recognize (@/, ~/, etc.)
	AliasPatterns []string
}

type OptimizedAPTEDAnalyzer struct {
	*APTEDAnalyzer
	// contains filtered or unexported fields
}

type ReachabilityAnalyzer struct {
	// contains filtered or unexported fields
}

type ReachabilityResult struct {
	// ReachableBlocks contains blocks that can be reached from entry
	ReachableBlocks map[string]*BasicBlock

	// UnreachableBlocks contains blocks that cannot be reached from entry
	UnreachableBlocks map[string]*BasicBlock

	// TotalBlocks is the total number of blocks analyzed
	TotalBlocks int

	// ReachableCount is the number of reachable blocks
	ReachableCount int

	// UnreachableCount is the number of unreachable blocks
	UnreachableCount int

	// AnalysisTime is the time taken to perform the analysis
	AnalysisTime time.Duration
}

type SeverityLevel string

type StarMedoidGrouping struct {
	// contains filtered or unexported fields
}

type TreeConverter struct {
	// contains filtered or unexported fields
}

type TreeEditResult struct {
	Distance   float64
	Similarity float64
	Tree1Size  int
	Tree2Size  int
	Operations int // Estimated number of edit operations
}

type TreeNode struct {
	// Unique identifier for this node
	ID int

	// Label for the node (typically the node type or value)
	Label string

	// Tree structure
	Children []*TreeNode
	Parent   *TreeNode

	// APTED-specific fields for optimization
	PostOrderID  int  // Post-order traversal position
	LeftMostLeaf int  // Left-most leaf descendant
	KeyRoot      bool // Whether this node is a key root

	// Optional metadata from original AST
	OriginalNode *parser.Node
}

type WeightedCostModel struct {
	InsertWeight  float64
	DeleteWeight  float64
	RenameWeight  float64
	BaseCostModel CostModel
}