analyzer

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

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

type AggregateComplexity struct {
	TotalFunctions    int
	AverageComplexity float64
	MaxComplexity     int
	MinComplexity     int
	HighRiskCount     int
	MediumRiskCount   int
	LowRiskCount      int
}

type AggregateRawMetrics struct {
	FilesAnalyzed  int
	SLOC           int
	LLOC           int
	CommentLines   int
	DocstringLines int
	BlankLines     int
	TotalLines     int
	CommentRatio   float64
}

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 CBOOptions struct {
	IncludeBuiltins   bool
	IncludeImports    bool
	PublicClassesOnly bool
	ExcludePatterns   []string
	LowThreshold      int // Default: 3 (industry standard)
	MediumThreshold   int // Default: 7 (industry standard)
}

type CBOResult struct {
	// Core CBO metric
	CouplingCount int

	// Class information
	ClassName string
	FilePath  string
	StartLine int
	EndLine   int

	// Dependency breakdown
	InheritanceDependencies     int
	TypeHintDependencies        int
	InstantiationDependencies   int
	AttributeAccessDependencies int
	ImportDependencies          int

	// Detailed dependency list
	DependentClasses []string

	// Risk assessment
	RiskLevel string // "low", "medium", "high"

	// Additional class metadata
	IsAbstract  bool
	BaseClasses []string
	Methods     []string
	Attributes  []string
}

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 CFGFeatures struct {
	BlockCount       int              // Number of basic blocks
	EdgeCount        int              // Number of edges
	EdgeTypeCounts   map[EdgeType]int // Distribution of edge types
	CyclomaticNumber int              // Cyclomatic complexity: V(G) = E - N + 2P
	BranchingFactor  float64          // Average number of successors per block
	LoopEdgeCount    int              // Number of loop back-edges
	ConditionalCount int              // Number of conditional branches
}

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 CircularDependency struct {
	Modules      []string          // Modules involved in the cycle
	Dependencies []DependencyChain // The dependency chains that form the cycle
	Severity     CycleSeverity     // Severity level of this cycle
	Size         int               // Number of modules in the cycle
	Description  string            // Human-readable description
}

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

type CircularDependencyResult struct {
	HasCircularDependencies bool                  // True if any cycles were found
	TotalCycles             int                   // Total number of cycles detected
	TotalModulesInCycles    int                   // Total number of modules involved in cycles
	CircularDependencies    []*CircularDependency // All detected circular dependencies

	// Severity breakdown
	LowSeverityCycles      int // Number of low severity cycles
	MediumSeverityCycles   int // Number of medium severity cycles
	HighSeverityCycles     int // Number of high severity cycles
	CriticalSeverityCycles int // Number of critical severity cycles

	// Most problematic cycles
	LargestCycle       *CircularDependency // Cycle with most modules
	MostComplexCycle   *CircularDependency // Cycle with most dependency chains
	CoreInfrastructure []string            // Modules that appear in multiple cycles
}

type ClassificationResult struct {
	CloneType  CloneType
	Similarity float64
	Confidence float64
	Analyzer   string
}

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

type CloneClassifierConfig struct {
	Type1Threshold         float64
	Type2Threshold         float64
	Type3Threshold         float64
	Type4Threshold         float64
	EnableTextualAnalysis  bool
	EnableSemanticAnalysis bool
	EnableDFAAnalysis      bool // Enable Data Flow Analysis for enhanced Type-4 detection
}

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 // Usually > domain.DefaultType1CloneThreshold
	Type2Threshold float64 // Usually > domain.DefaultType2CloneThreshold
	Type3Threshold float64 // Usually > domain.DefaultType3CloneThreshold
	Type4Threshold float64 // Usually > domain.DefaultType4CloneThreshold

	// Minimum similarity threshold for clone reporting (user-configurable via --clone-threshold)
	SimilarityThreshold float64

	// Maximum edit distance allowed
	MaxEditDistance float64

	// Whether to ignore differences in literals
	IgnoreLiterals bool

	// Whether to ignore differences in identifiers
	IgnoreIdentifiers bool

	// Whether to skip docstrings from AST comparison (default: true)
	// Docstrings are the first Expr(Constant(str)) in function/class/module bodies
	SkipDocstrings bool

	// Cost model to use for APTED
	CostModelType string // "default", "python", "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 // デフォルト: GroupingModeConnected
	GroupingThreshold float64      // デフォルト: Type3Threshold
	KCoreK            int          // デフォルト: 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)

	// Multi-dimensional classification (optional, opt-in)
	EnableMultiDimensionalAnalysis bool // Enable multi-dimensional clone type classification
	EnableTextualAnalysis          bool // Enable Type-1 textual analysis (increases memory usage)
	EnableSemanticAnalysis         bool // Enable Type-4 semantic/CFG analysis (increases CPU usage)
	EnableDFAAnalysis              bool // Enable Data Flow Analysis for enhanced Type-4 detection

	// Framework pattern handling (reduces false positives for dataclass, Pydantic, etc.)
	ReduceBoilerplateSimilarity bool    // Apply lower weight to boilerplate nodes (default: true)
	BoilerplateMultiplier       float64 // Cost multiplier for boilerplate nodes (default: 0.1)
}

type CloneGroup struct {
	ID         int             // Unique identifier for this group
	Fragments  []*CodeFragment // All fragments in this group
	CloneType  CloneType       // Primary type of clones in this group
	Similarity float64         // Average similarity within the group
	Size       int             // Number of fragments
}

type ClonePair struct {
	Fragment1  *CodeFragment
	Fragment2  *CodeFragment
	Similarity float64   // Similarity score (0.0 to 1.0)
	Distance   float64   // Edit distance
	CloneType  CloneType // Type of clone detected
	Confidence float64   // Confidence in the detection (0.0 to 1.0)
}

type CloneType int

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)
	Features   []string // Pre-computed features for Jaccard similarity
}

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

type CognitiveComplexityResult struct {
	// Total cognitive complexity score
	Total int

	// Function/method information
	FunctionName string
	StartLine    int
	EndLine      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

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

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

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

type ConstructorAnalyzer 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 CouplingMetricsOptions struct {
	IncludeAbstractness bool               // Calculate abstractness metrics
	ComplexityData      map[string]int     // Complexity data from complexity analysis
	ClonesData          map[string]float64 // Clone data from clone analysis
	DeadCodeData        map[string]int     // Dead code data from dead code analysis
}

type CycleSeverity string

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

type DFAFeatures struct {
	TotalDefs       int // Total number of definitions
	TotalUses       int // Total number of uses
	TotalPairs      int // Total number of def-use pairs
	UniqueVariables int // Number of unique variables

	AvgChainLength  float64 // Average uses per definition
	MaxChainLength  int     // Maximum def-use chain length
	CrossBlockPairs int     // Def-use pairs spanning blocks
	IntraBlockPairs int     // Def-use pairs within same block

	DefKindCounts map[DefUseKind]int // Distribution of definition kinds
	UseKindCounts map[DefUseKind]int // Distribution of use kinds
}

type DFAInfo struct {
	CFG       *CFG
	Chains    map[string]*DefUseChain    // Variable name -> chain
	BlockDefs map[string][]*VarReference // Block ID -> definitions in block
	BlockUses map[string][]*VarReference // Block ID -> uses in block
}

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

type DIAntipatternOptions struct {
	ConstructorParamThreshold int
	MinSeverity               domain.DIAntipatternSeverity
}

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 DefUseChain struct {
	Variable string
	Defs     []*VarReference
	Uses     []*VarReference
	Pairs    []*DefUsePair
}

type DefUseKind int

type DefUsePair struct {
	Def *VarReference
	Use *VarReference
}

type DefaultCostModel struct{}

type DependencyChain struct {
	From   string   // Starting module
	To     string   // Ending module
	Path   []string // Complete dependency path
	Length int      // Length of the chain
}

type DependencyEdge struct {
	From       string             // Source module name
	To         string             // Target module name
	EdgeType   DependencyEdgeType // Type of dependency
	ImportInfo *ImportInfo        // Details about the import
}

type DependencyEdgeType string

type DependencyGraph struct {
	// Graph structure
	Nodes map[string]*ModuleNode // Module name -> ModuleNode
	Edges []*DependencyEdge      // All dependency relationships

	// Graph metadata
	TotalModules int      // Total number of modules
	TotalEdges   int      // Total number of dependencies
	RootModules  []string // Modules with no dependencies
	LeafModules  []string // Modules with no dependents
	ProjectRoot  string   // Project root directory

	// Analysis results
	CyclicGroups  [][]string                // Strongly connected components (cycles)
	ModuleMetrics map[string]*ModuleMetrics // Module-level metrics
	SystemMetrics *SystemMetrics            // System-wide metrics
}

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 FileComplexityAnalyzer struct {
	// contains filtered or unexported fields
}

type GroupingConfig struct {
	Mode           GroupingMode
	Threshold      float64 // Minimum similarity for group membership
	KCoreK         int     // K value for k-core mode (default: 2)
	Type1Threshold float64 // Type-1 clone threshold
	Type2Threshold float64 // Type-2 clone threshold
	Type3Threshold float64 // Type-3 clone threshold
	Type4Threshold float64 // Type-4 clone threshold
}

type GroupingMode string

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

type HashFunc func(uint64) uint64

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

type ImportInfo struct {
	Statement      string   // Original import statement
	ImportedNames  []string // Names imported (for from imports)
	Alias          string   // Alias used (if any)
	IsRelative     bool     // True for relative imports
	Level          int      // Level for relative imports (number of dots)
	Line           int      // Line number where import occurs
	IsTypeChecking bool     // True if import is inside a TYPE_CHECKING block
}

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

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

type LCOMOptions struct {
	LowThreshold    int // Default: 2 (LCOM4 <= 2 is low risk)
	MediumThreshold int // Default: 5 (LCOM4 3-5 is medium risk)
	ExcludePatterns []string
}

type LCOMResult struct {
	// Core LCOM4 metric - number of connected components
	LCOM4 int

	// Class information
	ClassName string
	FilePath  string
	StartLine int
	EndLine   int

	// Method statistics
	TotalMethods    int // All methods found in class
	ExcludedMethods int // @staticmethod and @classmethod excluded

	// Instance variable count
	InstanceVariables int // Distinct self.xxx variables

	// Connected component details
	MethodGroups [][]string // Method names grouped by connected component

	// Risk assessment
	RiskLevel string // "low", "medium", "high"
}

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 ModuleAnalysisOptions struct {
	ProjectRoot       string   // Project root directory
	PythonPath        []string // Additional Python path entries
	ExcludePatterns   []string // Module patterns to exclude
	IncludePatterns   []string // Module patterns to include (default: ["**/*.py"])
	IncludeStdLib     bool     // Include standard library dependencies
	IncludeThirdParty bool     // Include third-party dependencies
	FollowRelative    bool     // Follow relative imports
}

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

type ModuleMetrics struct {
	// Coupling metrics
	AfferentCoupling int     // Ca - Number of modules that depend on this module
	EfferentCoupling int     // Ce - Number of modules this module depends on
	Instability      float64 // I = Ce / (Ca + Ce) - Measure of instability
	Abstractness     float64 // A - Measure of abstractness (0-1)
	Distance         float64 // D - Distance from main sequence

	// Size metrics
	LinesOfCode     int // Total lines of code
	PublicInterface int // Number of public functions/classes

	// Quality metrics
	CyclomaticComplexity int // Average complexity of functions
}

type ModuleNode struct {
	// Module identification
	Name         string // Module name (e.g., "mypackage.submodule")
	FilePath     string // Absolute path to the Python file
	RelativePath string // Relative path from project root
	Package      string // Package name (e.g., "mypackage")
	IsPackage    bool   // True if this represents a package (__init__.py)

	// Dependencies
	Imports      []string        // Direct imports from this module
	ImportedBy   []string        // Modules that import this module
	Dependencies map[string]bool // Set of modules this module depends on
	Dependents   map[string]bool // Set of modules that depend on this module

	// Metrics
	InDegree  int // Number of incoming dependencies
	OutDegree int // Number of outgoing dependencies

	// Module information
	LineCount     int      // Total lines in the module
	FunctionCount int      // Number of functions defined
	ClassCount    int      // Number of classes defined
	PublicNames   []string // Public names exported by this module
}

type NestingDepthResult struct {
	// Maximum nesting depth found in the function
	MaxDepth int

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

	// Location of deepest nesting (line number)
	DeepestNestingLine int
}

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

type PythonCostModel 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

	// Whether to reduce weight for boilerplate nodes (type annotations, decorators, Field() calls)
	ReduceBoilerplateWeight bool

	// Multiplier for boilerplate nodes (default: 0.1)
	BoilerplateMultiplier float64
}

type RawMetricsResult struct {
	FilePath       string
	SLOC           int
	LLOC           int
	CommentLines   int
	DocstringLines int
	BlankLines     int
	TotalLines     int
	CommentRatio   float64
	// contains filtered or unexported fields
}

type ReExportEntry struct {
	Name         string // The exported name (e.g., "SomeClass")
	SourceModule string // The actual source module (e.g., "pkg_a.module_x")
	SourceName   string // The name in the source module (may differ if aliased)
}

type ReExportMap struct {
	PackageName string                    // The package name (e.g., "pkg_a")
	Exports     map[string]*ReExportEntry // name -> source info
	AllDeclared []string                  // Names in __all__ if declared
	HasAllDecl  bool                      // True if __all__ is explicitly declared
}

type ReExportResolver struct {
	// 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 SemanticSimilarityAnalyzer struct {
	// contains filtered or unexported fields
}

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

type SeverityLevel string

type SimilarityAnalyzer interface {
	// ComputeSimilarity returns a similarity score between 0.0 and 1.0
	ComputeSimilarity(fragment1, fragment2 *CodeFragment) float64

	// GetName returns the name of this analyzer
	GetName() string
}

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

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

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

type SystemMetrics struct {
	// Overall structure
	TotalModules      int // Total number of modules
	TotalDependencies int // Total number of dependencies
	PackageCount      int // Number of packages

	// Dependency metrics
	AverageFanIn    float64 // Average number of incoming dependencies
	AverageFanOut   float64 // Average number of outgoing dependencies
	DependencyRatio float64 // Total dependencies / Total modules

	// Coupling and cohesion
	AverageInstability    float64 // System average instability
	AverageAbstractness   float64 // System average abstractness
	MainSequenceDeviation float64 // Average distance from main sequence

	// Modularity
	ModularityIndex float64 // Measure of system decomposition quality
	ComponentRatio  float64 // Ratio of strongly connected components

	// Quality indicators
	CyclicDependencies int     // Number of modules in cycles
	MaxDependencyDepth int     // Maximum dependency chain length
	SystemComplexity   float64 // Overall system complexity score

	// Refactoring
	RefactoringPriority []string // Modules needing refactoring (highest priority first)
}

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

type TextualSimilarityConfig struct {
	NormalizeWhitespace bool
	RemoveComments      bool
}

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 VarReference struct {
	Name      string       // Variable name
	Kind      DefUseKind   // Type of reference
	Block     *BasicBlock  // Which block contains this reference
	Statement *parser.Node // The AST statement containing the reference
	Position  int          // Position within block's Statements slice
}

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