ast

type ASTResult struct {
	// Language is the detected language name (e.g. "go", "python").
	Language string

	// FilePath is the path that was passed to ParseFile.
	FilePath string

	// Root is the root node of the parse tree.  Use this for direct
	// tree traversal when the caller needs full control.
	Root *gotreesitter.Node

	// Source is a reference to the parsed source bytes.  It is retained
	// only for the lifetime of the BoundTree; callers that need the
	// source longer should keep their own copy.
	Source []byte

	// Tree is the underlying parse tree.  Callers MUST call result.Release()
	// when finished to free arena memory.
	Tree *gotreesitter.Tree

	// Bound is a convenience wrapper that keeps the source buffer alive
	// so that Node.Text / NodeType queries work without the caller
	// tracking the source slice.
	Bound *gotreesitter.BoundTree

	// Symbols is a list of top-level symbols extracted from the AST.
	Symbols []Symbol

	// Calls is a list of call edges extracted from the AST.
	// Each edge represents a function/method call found within a function body.
	Calls []CallEdge
}

type BodyExtractor interface {
	// ExtractBody returns the source text of the body for the given node,
	// or empty string if the node is not a function-like declaration.
	ExtractBody(node *gotreesitter.Node, bt *gotreesitter.BoundTree) string
}

type CacheStats struct {
	Hits      int64
	Misses    int64
	Evictions int64
	Size      int // number of entries in the cache
}

type CallEdge struct {
	CallerName string // name of the calling function
	CalleeName string // name of the called function
	Line       int    // line number of the call
	CallerLine int    // line number of the caller function
}

type GrammarBlob struct {
	Language *gotreesitter.Language
	Name     string
	LoadedAt time.Time
	Size     int
}

type GrammarCache interface {
	// Get returns the cached GrammarBlob for name, or (nil, false) if
	// not found.  Increments the hit counter on found, miss counter
	// on not-found.
	Get(name string) (*GrammarBlob, bool)

	// Put stores a GrammarBlob.  The key is derived from blob.Name.
	// If a blob with the same name already exists, it is replaced and
	// the eviction counter is incremented.
	Put(blob *GrammarBlob)

	// Invalidate removes the cache entry for name.  If no entry exists,
	// this is a no-op.
	Invalidate(name string)

	// InvalidateAll removes all entries from the cache.
	InvalidateAll()

	// Stats returns current cache statistics.
	Stats() CacheStats

	// Names returns a sorted copy of all cached language names.
	Names() []string
}

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

type ScopedSymbol struct {
	Symbol // embed the existing Symbol for Name, Kind, StartLine, etc.

	// Scope is the parent scope path, e.g. "MyClass" for a method inside
	// a class, or "MyClass.NestedStruct" for deeper nesting.
	// Empty string for top-level symbols (Depth == 0).
	Scope string

	// Depth is the nesting level: 0 = top-level, 1 = child of top-level, etc.
	Depth int
}

type Symbol struct {
	// Name is the declared identifier (e.g. "MyFunc", "MyStruct").
	Name string

	// Kind is a normalised symbol kind: "function", "method", "class",
	// "interface", "type", "variable", "constant", "import", "decorator",
	// "property", "enum", or "module".
	Kind string

	// StartLine is the 1-based line number where the symbol starts.
	StartLine int

	// EndLine is the 1-based line number where the symbol ends (inclusive).
	EndLine int

	// StartByte is the 0-based byte offset where the symbol starts.
	StartByte int

	// EndByte is the 0-based byte offset where the symbol ends.
	EndByte int

	// Body is the source text of the function/method body (between braces
	// or after colon). Empty for non-function symbols (classes, types,
	// variables, etc.), except for Python classes where the block IS the
	// body.
	Body string
}

type WalkFn func(node *gotreesitter.Node, nodeType string, depth int) bool