processor

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

type ClassDefinition struct {
	Name      string
	FQN       string
	FilePath  string
	StartByte uint32
	EndByte   uint32
	Language  string
}

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

type DistilledCodeSnippet struct {
	StartByte uint32
	EndByte   uint32
	FQN       string // Fully Qualified Name of the symbol
	Type      string // "function", "class", "method"
}

type DistilledMultiFile struct {
	OriginalFilePath string
	OriginalContent  []byte
	Snippets         []DistilledCodeSnippet
	DistilledContent string
	Language         string
}

type DistilledProject struct {
	Files       map[string]*DistilledMultiFile // Map of file path to distilled file
	EntryPoints []string                       // Entry point FQNs
}

type FileResult struct {
	Index  int
	Result *ir.DistilledFile
	Error  error
}

type FileTask struct {
	Index           int
	Path            string
	FileInfo        os.FileInfo
	ExplicitInclude bool
}

type FunctionDefinition struct {
	Name      string
	FQN       string
	FilePath  string
	StartByte uint32
	EndByte   uint32
	Language  string
}

type LanguageProcessor interface {
	// Language returns the language identifier (e.g., "go", "python", "javascript")
	Language() string

	// Version returns the processor version
	Version() string

	// SupportedExtensions returns file extensions this processor handles
	SupportedExtensions() []string

	// CanProcess checks if this processor can handle the given file
	CanProcess(filename string) bool

	// Process parses source code and returns the IR representation
	Process(ctx context.Context, reader io.Reader, filename string) (*ir.DistilledFile, error)

	// ProcessWithOptions parses with specific options
	ProcessWithOptions(ctx context.Context, reader io.Reader, filename string, opts ProcessOptions) (*ir.DistilledFile, error)
}

type MultiError struct {
	Errors []error
}

type ProcessOptions struct {
	// IncludeImplementation includes function/method bodies
	IncludeImplementation bool

	// IncludeComments includes comment nodes
	IncludeComments bool

	// IncludeImports includes import statements
	IncludeImports bool

	// IncludePrivate includes private/internal declarations (legacy - removes both private and protected)
	IncludePrivate bool

	// RemovePrivateOnly removes only private members (not protected)
	RemovePrivateOnly bool

	// RemoveProtectedOnly removes only protected members (not private)
	RemoveProtectedOnly bool

	// RemoveInternalOnly removes only internal/package-private members
	RemoveInternalOnly bool

	// IncludePublic includes public members (for formatter instructions)
	IncludePublic bool

	// IncludeProtected includes protected members (for formatter instructions)
	IncludeProtected bool

	// IncludeInternal includes internal/package-private members (for formatter instructions)
	IncludeInternal bool

	// IncludeDocstrings includes documentation comments (when false, removes them)
	IncludeDocstrings bool

	// IncludeAnnotations includes decorators/annotations (when false, removes them)
	IncludeAnnotations bool

	// IncludeFields includes class fields/properties (when false, removes them)
	IncludeFields bool

	// IncludeMethods includes methods/functions (when false, removes them)
	IncludeMethods bool

	// ExpandSymbols holds glob patterns; functions/methods whose name matches
	// keep their implementation even when implementations are otherwise stripped.
	ExpandSymbols []string

	// MaxDepth limits the depth of nested structures
	MaxDepth int

	// SymbolResolution enables symbol cross-referencing
	SymbolResolution bool

	// IncludeLineNumbers adds line number information
	IncludeLineNumbers bool

	// Workers specifies the number of parallel workers for processing
	// 0 = auto (80% of CPU cores), 1 = serial processing
	Workers int

	// RawMode processes all text files without parsing
	RawMode bool

	// Recursive controls whether to process directories recursively
	Recursive bool

	// BasePath is the original path provided by the user (for relative path calculation)
	BasePath string

	// FilePathType controls how paths appear in output: "relative" or "absolute"
	FilePathType string

	// RelativePathPrefix is a custom prefix for relative paths (e.g., "src/")
	RelativePathPrefix string

	// IncludePatterns are file patterns to include (e.g., "*.go", "*.py")
	IncludePatterns []string

	// ExcludePatterns are file patterns to exclude (e.g., "*test*", "*.json")
	ExcludePatterns []string

	// ExplicitInclude indicates this file was explicitly included via !pattern
	ExplicitInclude bool
}

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

type ProcessorError struct {
	File     string
	Line     int
	Column   int
	Message  string
	Severity string // "error", "warning", "info"
	Code     string // Error code for tooling
}

type RawProcessor struct {
	BaseProcessor
}

type Registry interface {
	// Register adds a processor to the registry
	Register(processor LanguageProcessor) error

	// Get returns a processor for the given language
	Get(language string) (LanguageProcessor, bool)

	// GetByFilename returns a processor that can handle the file
	GetByFilename(filename string) (LanguageProcessor, bool)

	// List returns all registered language identifiers
	List() []string
}