readgo

type AnalysisError struct {
	Op      string // Operation that failed (e.g., "load package", "parse file")
	Path    string // File or package path where the error occurred
	Wrapped error  // The underlying error
}

type AnalysisResult struct {
	Name       string         `json:"name"`
	Path       string         `json:"path"`
	StartTime  string         `json:"start_time"`
	AnalyzedAt time.Time      `json:"analyzed_at"`
	Types      []TypeInfo     `json:"types,omitempty"`
	Functions  []FunctionInfo `json:"functions,omitempty"`
	Imports    []string       `json:"imports,omitempty"`
}

type AnalyzerOptions struct {
	// WorkDir is the working directory for the analyzer
	WorkDir string

	// CacheTTL is the time-to-live for cached entries
	// If zero, caching is disabled
	CacheTTL time.Duration

	// MaxCacheSize is the maximum number of entries in each cache type
	// If zero, no limit is applied
	MaxCacheSize int

	// AnalysisTimeout is the timeout for analysis operations
	// If zero, no timeout is applied
	AnalysisTimeout time.Duration

	// EnableConcurrentAnalysis enables concurrent analysis for large projects
	EnableConcurrentAnalysis bool

	// MaxConcurrentAnalysis is the maximum number of concurrent analyses
	// If zero, defaults to runtime.NumCPU()
	MaxConcurrentAnalysis int
}

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

type CodeAnalyzer interface {
	// FindType finds a specific type in the given package
	FindType(ctx context.Context, pkgPath, typeName string) (*TypeInfo, error)

	// FindInterface finds a specific interface in the given package
	FindInterface(ctx context.Context, pkgPath, interfaceName string) (*TypeInfo, error)

	// FindFunction finds a specific function in the given package
	FindFunction(ctx context.Context, pkgPath, funcName string) (*TypeInfo, error)

	// AnalyzeFile analyzes a specific Go source file
	AnalyzeFile(ctx context.Context, filePath string) (*AnalysisResult, error)

	// AnalyzePackage analyzes a Go package
	AnalyzePackage(ctx context.Context, pkgPath string) (*AnalysisResult, error)

	// AnalyzeProject analyzes a Go project at the specified path
	AnalyzeProject(ctx context.Context, projectPath string) (*AnalysisResult, error)
}

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

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

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

type FileContent struct {
	Content   []byte             `json:"content"`   // File content
	Functions []FunctionPosition `json:"functions"` // Function positions
}

type FileTreeNode struct {
	Name     string          `json:"name"`
	Path     string          `json:"path"`
	Type     string          `json:"type"` // "file" or "directory"
	Size     int64           `json:"size,omitempty"`
	ModTime  time.Time       `json:"mod_time,omitempty"`
	Children []*FileTreeNode `json:"children,omitempty"`
}

type FileType string

type FunctionInfo struct {
	Name       string `json:"name"`
	Package    string `json:"package"`
	IsExported bool   `json:"is_exported"`
}

type FunctionPosition struct {
	Name      string `json:"name"`       // Function name
	StartLine int    `json:"start_line"` // Starting line number
	EndLine   int    `json:"end_line"`   // Ending line number
}

type Option func(*AnalyzerOptions)

type PackageError struct {
	Package string   // Package path
	Op      string   // Operation that failed
	Errors  []string // List of errors
	Wrapped error    // The underlying error
}

type ReadOptions struct {
	IncludeComments bool `json:"include_comments"`
	StripSpaces     bool `json:"strip_spaces"`
}

type SourceReader interface {
	// GetFileTree returns the file tree starting from the given root
	GetFileTree(ctx context.Context, root string, opts TreeOptions) (*FileTreeNode, error)

	// ReadSourceFile reads a source file with the specified options
	ReadSourceFile(ctx context.Context, path string, opts ReadOptions) ([]byte, error)

	// GetPackageFiles returns all files in a package
	GetPackageFiles(ctx context.Context, pkgPath string, opts TreeOptions) ([]*FileTreeNode, error)

	// SearchFiles searches for files matching the given pattern
	SearchFiles(ctx context.Context, pattern string, opts TreeOptions) ([]*FileTreeNode, error)
}

type TreeOptions struct {
	FileTypes       FileType `json:"file_types"`
	ExcludePatterns []string `json:"exclude_patterns,omitempty"`
	IncludePatterns []string `json:"include_patterns,omitempty"`
}

type TypeCacheKey struct {
	Package  string
	TypeName string
	Kind     string
}

type TypeInfo struct {
	Name       string `json:"name"`
	Package    string `json:"package"`
	Type       string `json:"type"`
	IsExported bool   `json:"is_exported"`
}

type TypeLookupError struct {
	TypeName string // Name of the type being looked up
	Package  string // Package where the lookup was performed
	Kind     string // Kind of type (e.g., "interface", "struct")
	Wrapped  error  // The underlying error
}

type ValidationError struct {
	File    string // File where the error occurred
	Line    int    // Line number where the error occurred
	Column  int    // Column number where the error occurred
	Message string // Error message
	Wrapped error  // The underlying error
}

type ValidationResult struct {
	Name       string              `json:"name"`
	Path       string              `json:"path"`
	StartTime  string              `json:"start_time"`
	AnalyzedAt time.Time           `json:"analyzed_at"`
	Errors     []string            `json:"errors,omitempty"`
	Warnings   []ValidationWarning `json:"warnings,omitempty"`
}

type ValidationWarning struct {
	Type    string `json:"type"`
	Message string `json:"message"`
	File    string `json:"file,omitempty"`
	Line    int    `json:"line,omitempty"`
	Column  int    `json:"column,omitempty"`
}

type Validator interface {
	// ValidateFile validates a specific Go source file
	ValidateFile(ctx context.Context, filePath string) (*ValidationResult, error)

	// ValidatePackage validates a Go package
	ValidatePackage(ctx context.Context, pkgPath string) (*ValidationResult, error)

	// ValidateProject validates the entire project
	ValidateProject(ctx context.Context) (*ValidationResult, error)
}