reason

type BreakingAnalysis struct {
	// TargetID is the symbol being analyzed.
	TargetID string `json:"target_id"`

	// IsBreaking indicates if any breaking changes were detected.
	IsBreaking bool `json:"is_breaking"`

	// BreakingChanges lists all detected breaking changes.
	BreakingChanges []BreakingChange `json:"breaking_changes"`

	// SafeChanges lists changes that are safe (non-breaking).
	SafeChanges []string `json:"safe_changes"`

	// CallersAffected is the count of affected callers.
	CallersAffected int `json:"callers_affected"`

	// Confidence is how confident we are in the analysis (0.0-1.0).
	Confidence float64 `json:"confidence"`

	// Limitations lists what we couldn't check.
	Limitations []string `json:"limitations"`
}

type BreakingChange struct {
	// Type categorizes the breaking change.
	Type BreakingChangeType `json:"type"`

	// Description explains what changed.
	Description string `json:"description"`

	// Affected lists the IDs of affected callers/users.
	Affected []string `json:"affected"`

	// Severity indicates how serious the break is.
	Severity Severity `json:"severity"`

	// AutoFixable indicates if an automatic fix can be generated.
	AutoFixable bool `json:"auto_fixable"`

	// SuggestedFix is the suggested fix if auto-fixable.
	SuggestedFix string `json:"suggested_fix,omitempty"`
}

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

type BreakingChangeType string

type CRSRecorder interface {
	// RecordToolStep records a tool execution step in the CRS.
	RecordToolStep(ctx context.Context, toolName string, resultCount int, duration time.Duration, err error)
}

type CallerUpdate struct {
	// CallerID is the symbol ID of the caller.
	CallerID string `json:"caller_id"`

	// CallerName is the name of the calling function.
	CallerName string `json:"caller_name"`

	// CurrentCall is the current call expression (if extractable).
	CurrentCall string `json:"current_call,omitempty"`

	// NeededCall is what the call should be changed to.
	NeededCall string `json:"needed_call,omitempty"`

	// FilePath is the file containing the caller.
	FilePath string `json:"file_path"`

	// Line is the line number of the call.
	Line int `json:"line"`

	// UpdateType describes the type of update needed.
	UpdateType string `json:"update_type"`
}

type ChangeSimulation struct {
	// TargetID is the symbol being changed.
	TargetID string `json:"target_id"`

	// Valid indicates if the change appears valid.
	Valid bool `json:"valid"`

	// CallersToUpdate lists callers that need to be updated.
	CallersToUpdate []CallerUpdate `json:"callers_to_update"`

	// ImportsNeeded lists imports that would need to be added.
	ImportsNeeded []string `json:"imports_needed"`

	// TypeMismatches lists type incompatibilities introduced.
	TypeMismatches []TypeMismatch `json:"type_mismatches"`

	// TestsAffected lists test symbols that would be affected.
	TestsAffected []string `json:"tests_affected"`

	// Confidence is how confident we are in the simulation (0.0-1.0).
	Confidence float64 `json:"confidence"`

	// Limitations lists what we couldn't simulate.
	Limitations []string `json:"limitations"`
}

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

type ChangeValidation struct {
	// SyntaxValid indicates if the syntax is correct.
	SyntaxValid bool `json:"syntax_valid"`

	// TypesValid indicates if all type references exist.
	TypesValid bool `json:"types_valid"`

	// ImportsValid indicates if all imports can resolve.
	ImportsValid bool `json:"imports_valid"`

	// Errors lists all validation errors found.
	Errors []ValidationError `json:"errors,omitempty"`

	// Warnings lists non-fatal issues found.
	Warnings []ValidationWarning `json:"warnings,omitempty"`

	// Scope describes the validation scope.
	// Always "syntactic" for this validator.
	Scope string `json:"scope"`

	// Confidence is how confident we are (0.0-1.0).
	Confidence float64 `json:"confidence"`
}

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

type CodeMetrics struct {
	// LineCount is the number of lines in the function body.
	LineCount int `json:"line_count"`

	// CyclomaticComplexity measures decision points (branches, loops).
	CyclomaticComplexity int `json:"cyclomatic_complexity"`

	// ParameterCount is the number of parameters.
	ParameterCount int `json:"parameter_count"`

	// ReturnCount is the number of return values.
	ReturnCount int `json:"return_count"`

	// NestingDepth is the maximum nesting level.
	NestingDepth int `json:"nesting_depth"`

	// CognitiveComplexity measures how hard the code is to understand.
	CognitiveComplexity int `json:"cognitive_complexity"`

	// CallerCount is the number of functions that call this one.
	CallerCount int `json:"caller_count"`

	// CalleeCount is the number of functions this one calls.
	CalleeCount int `json:"callee_count"`

	// IsExported indicates if the function is exported/public.
	IsExported bool `json:"is_exported"`
}

type ConfidenceAdjustment struct {
	// Reason explains why the adjustment is applied.
	Reason string `json:"reason"`

	// Multiplier is the factor to multiply confidence by.
	// Values < 1.0 decrease confidence, > 1.0 increase confidence.
	Multiplier float64 `json:"multiplier"`
}

type ConfidenceCalibration struct {
	// BaseScore is the starting confidence.
	BaseScore float64 `json:"base_score"`

	// Adjustments lists all adjustments applied.
	Adjustments []ConfidenceAdjustment `json:"adjustments"`

	// FinalScore is the calibrated result.
	FinalScore float64 `json:"final_score"`
}

type ConfidenceLevel string

type CoverageReport struct {
	// TotalSymbols is the total number of symbols analyzed.
	TotalSymbols int `json:"total_symbols"`

	// CoveredSymbols is the number of symbols with test coverage.
	CoveredSymbols int `json:"covered_symbols"`

	// UncoveredSymbols lists symbols without coverage.
	UncoveredSymbols []string `json:"uncovered_symbols"`

	// CoveragePercent is the percentage of covered symbols.
	CoveragePercent float64 `json:"coverage_percent"`

	// TestCount is the total number of test functions.
	TestCount int `json:"test_count"`

	// Confidence is how confident we are in the report (0.0-1.0).
	Confidence float64 `json:"confidence"`
}

type FunctionPattern struct {
	// Package is the Go package path (e.g., "os", "net/http").
	Package string `json:"package,omitempty"`

	// Module is the Python/TypeScript module name (e.g., "os", "fs").
	Module string `json:"module,omitempty"`

	// Functions lists function names that have side effects.
	Functions []string `json:"functions"`

	// EffectType categorizes the side effect.
	EffectType SideEffectType `json:"effect_type"`

	// Reversible indicates if the effect can be undone.
	Reversible bool `json:"reversible"`

	// Idempotent indicates if repeating the call is safe.
	Idempotent bool `json:"idempotent"`

	// Description explains what the side effect does.
	Description string `json:"description"`
}

type ImportReference struct {
	Path string
	Line int
}

type InterfaceSatisfaction struct {
	// TypeName is the type being checked.
	TypeName string `json:"type_name"`

	// InterfaceName is the interface being checked against.
	InterfaceName string `json:"interface_name"`

	// Satisfied indicates if the type satisfies the interface.
	Satisfied bool `json:"satisfied"`

	// MissingMethods lists methods the type doesn't implement.
	MissingMethods []string `json:"missing_methods,omitempty"`

	// MatchedMethods lists methods that match.
	MatchedMethods []MethodMatch `json:"matched_methods,omitempty"`

	// Reason explains the result.
	Reason string `json:"reason"`

	// Confidence is how confident we are (0.0-1.0).
	Confidence float64 `json:"confidence"`
}

type MethodMatch struct {
	// InterfaceMethod is the method name from the interface.
	InterfaceMethod string `json:"interface_method"`

	// TypeMethod is the matching method from the type.
	TypeMethod string `json:"type_method"`

	// SignatureMatch indicates if signatures match exactly.
	SignatureMatch bool `json:"signature_match"`
}

type NopCRSRecorder struct{}

type ParameterInfo struct {
	// Name is the parameter name. May be empty for unnamed parameters.
	Name string `json:"name"`

	// Type is the parameter type information.
	Type TypeInfo `json:"type"`

	// Optional indicates if the parameter has a default value (Python/TS).
	Optional bool `json:"optional,omitempty"`

	// Default is the default value expression if optional.
	Default string `json:"default,omitempty"`
}

type ParsedSignature struct {
	// Name is the function/method name.
	Name string `json:"name"`

	// Receiver is the receiver type for methods. Nil for functions.
	Receiver *TypeInfo `json:"receiver,omitempty"`

	// Parameters lists all parameters in order.
	Parameters []ParameterInfo `json:"parameters"`

	// Returns lists all return types in order.
	Returns []TypeInfo `json:"returns"`

	// TypeParams lists generic type parameters if any.
	TypeParams []TypeParamInfo `json:"type_params,omitempty"`

	// Variadic indicates if the last parameter is variadic.
	Variadic bool `json:"variadic,omitempty"`

	// Language is the source language.
	Language string `json:"language"`
}

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

type RefactorSuggestions struct {
	// TargetID is the symbol being analyzed.
	TargetID string `json:"target_id"`

	// TargetName is the name of the symbol.
	TargetName string `json:"target_name"`

	// Suggestions lists all refactoring suggestions.
	Suggestions []Suggestion `json:"suggestions"`

	// Metrics contains the measured code characteristics.
	Metrics CodeMetrics `json:"metrics"`

	// OverallHealth is a score from 0-100 indicating code health.
	OverallHealth int `json:"overall_health"`

	// Limitations lists what we couldn't analyze.
	Limitations []string `json:"limitations"`
}

type RefactorType string

type RiskLevel string

type Severity string

type SideEffect struct {
	// Type categorizes the side effect (file_io, network, database, etc.).
	Type SideEffectType `json:"type"`

	// Operation describes the specific operation (e.g., "Write", "Query").
	Operation string `json:"operation"`

	// Location describes where the side effect occurs.
	Location string `json:"location"`

	// Description explains what the side effect does.
	Description string `json:"description"`

	// Reversible indicates if the effect can be undone.
	Reversible bool `json:"reversible"`

	// Idempotent indicates if repeating the call is safe.
	Idempotent bool `json:"idempotent"`

	// Transitive indicates if this effect comes from a called function.
	Transitive bool `json:"transitive"`

	// SourceFunctionID is the function that directly has the side effect.
	// For transitive effects, this is the callee that has the effect.
	SourceFunctionID string `json:"source_function_id,omitempty"`

	// CallChain shows the path from target to the side effect source.
	CallChain []string `json:"call_chain,omitempty"`
}

type SideEffectAnalysis struct {
	// TargetID is the symbol being analyzed.
	TargetID string `json:"target_id"`

	// IsPure indicates if the function has no side effects.
	IsPure bool `json:"is_pure"`

	// SideEffects lists all detected side effects.
	SideEffects []SideEffect `json:"side_effects"`

	// DirectEffects is the count of direct side effects.
	DirectEffects int `json:"direct_effects"`

	// TransitiveEffects is the count of transitive side effects.
	TransitiveEffects int `json:"transitive_effects"`

	// Confidence is how confident we are in the analysis (0.0-1.0).
	Confidence float64 `json:"confidence"`

	// Limitations lists what we couldn't analyze.
	Limitations []string `json:"limitations"`
}

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

type SideEffectPatterns struct {
	// Language is the programming language these patterns apply to.
	Language string `json:"language"`

	// FileIO patterns for file system operations.
	FileIO []FunctionPattern `json:"file_io"`

	// Network patterns for network operations.
	Network []FunctionPattern `json:"network"`

	// Database patterns for database operations.
	Database []FunctionPattern `json:"database"`

	// Logging patterns for logging operations.
	Logging []FunctionPattern `json:"logging"`

	// GlobalState patterns for global state mutations.
	GlobalState []FunctionPattern `json:"global_state"`

	// Process patterns for process/system operations.
	Process []FunctionPattern `json:"process"`

	// Environment patterns for environment variable operations.
	Environment []FunctionPattern `json:"environment"`
}

type SideEffectType string

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

type Suggestion struct {
	// Type categorizes the refactoring.
	Type RefactorType `json:"type"`

	// Description explains what should be done.
	Description string `json:"description"`

	// Rationale explains why this refactoring is suggested.
	Rationale string `json:"rationale"`

	// CodeBefore shows the current code pattern (snippet or description).
	CodeBefore string `json:"code_before,omitempty"`

	// CodeAfter shows the suggested code pattern (snippet or description).
	CodeAfter string `json:"code_after,omitempty"`

	// Confidence is how confident we are in this suggestion (0.0-1.0).
	Confidence float64 `json:"confidence"`

	// Basis explains what evidence supports this suggestion.
	Basis string `json:"basis"`

	// Risk indicates what could go wrong.
	Risk string `json:"risk"`

	// RiskLevel categorizes the risk.
	RiskLevel RiskLevel `json:"risk_level"`

	// Priority indicates suggested order of applying (1 = highest).
	Priority int `json:"priority"`

	// AffectedSymbols lists symbols that would be affected.
	AffectedSymbols []string `json:"affected_symbols,omitempty"`
}

type TestCoverage struct {
	// TargetID is the symbol being analyzed.
	TargetID string `json:"target_id"`

	// IsCovered indicates if any test exercises this symbol.
	IsCovered bool `json:"is_covered"`

	// DirectTests lists tests that directly call this symbol.
	DirectTests []TestInfo `json:"direct_tests"`

	// IndirectTests lists tests that call this symbol transitively.
	IndirectTests []TestInfo `json:"indirect_tests"`

	// CoverageDepth is the minimum call depth from any test.
	CoverageDepth int `json:"coverage_depth"`

	// Confidence is how confident we are in the analysis (0.0-1.0).
	Confidence float64 `json:"confidence"`

	// Limitations lists what we couldn't analyze.
	Limitations []string `json:"limitations"`
}

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

type TestInfo struct {
	// TestID is the test function symbol ID.
	TestID string `json:"test_id"`

	// TestName is the name of the test function.
	TestName string `json:"test_name"`

	// FilePath is the test file path.
	FilePath string `json:"file_path"`

	// CallDepth is how many calls away from the target.
	CallDepth int `json:"call_depth"`

	// CallPath is the chain of calls from test to target.
	CallPath []string `json:"call_path,omitempty"`
}

type TypeCompatibility struct {
	// SourceType is the type we have.
	SourceType string `json:"source_type"`

	// TargetType is the type we need.
	TargetType string `json:"target_type"`

	// Compatible indicates if the types are compatible.
	Compatible bool `json:"compatible"`

	// Reason explains why types are or aren't compatible.
	Reason string `json:"reason"`

	// Conversions lists possible conversions if not directly compatible.
	Conversions []string `json:"conversions,omitempty"`

	// Confidence is how confident we are (0.0-1.0).
	Confidence float64 `json:"confidence"`
}

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

type TypeInfo struct {
	// Name is the type name (e.g., "string", "*User", "[]byte").
	Name string `json:"name"`

	// Package is the package path for qualified types.
	// Empty for builtin types.
	Package string `json:"package,omitempty"`

	// IsPointer indicates if this is a pointer type.
	IsPointer bool `json:"is_pointer,omitempty"`

	// IsSlice indicates if this is a slice type.
	IsSlice bool `json:"is_slice,omitempty"`

	// IsMap indicates if this is a map type.
	IsMap bool `json:"is_map,omitempty"`

	// IsChannel indicates if this is a channel type.
	IsChannel bool `json:"is_channel,omitempty"`

	// IsVariadic indicates if this is a variadic parameter (...T).
	IsVariadic bool `json:"is_variadic,omitempty"`

	// ElementType is the element type for slices, arrays, maps, channels.
	ElementType *TypeInfo `json:"element_type,omitempty"`

	// KeyType is the key type for maps.
	KeyType *TypeInfo `json:"key_type,omitempty"`

	// TypeParams lists generic type parameters if any.
	TypeParams []string `json:"type_params,omitempty"`
}

type TypeMismatch struct {
	// Location describes where the mismatch occurs.
	Location string `json:"location"`

	// Expected is the type that was expected.
	Expected string `json:"expected"`

	// Got is the type that was found.
	Got string `json:"got"`

	// Suggestion is how to fix the mismatch.
	Suggestion string `json:"suggestion,omitempty"`
}

type TypeParamInfo struct {
	// Name is the type parameter name (e.g., "T", "K").
	Name string `json:"name"`

	// Constraint is the type constraint (e.g., "any", "comparable").
	Constraint string `json:"constraint,omitempty"`
}

type TypeReference struct {
	Name string
	Line int
}

type ValidationError struct {
	// Type categorizes the error.
	Type string `json:"type"` // syntax, type_ref, import

	// Message describes the error.
	Message string `json:"message"`

	// Line is the line number (1-indexed).
	Line int `json:"line"`

	// Column is the column number (0-indexed).
	Column int `json:"column"`

	// Severity is the error severity.
	Severity string `json:"severity"` // error, warning
}

type ValidationWarning struct {
	// Type categorizes the warning.
	Type string `json:"type"`

	// Message describes the warning.
	Message string `json:"message"`

	// Line is the line number (1-indexed).
	Line int `json:"line"`
}