chunker

type Analysis struct {
	Chunks []Chunk
	Edges  []Edge // nil when the language declares no EdgeRules
}

type Chunk struct {
	Content  string   // raw source text of this chunk
	FilePath string   // absolute path to the source file
	Language string   // language name as reported by LanguageConfig.Name
	NodeKind string   // tree-sitter node kind, e.g. "function_declaration", "class_definition"
	Name     string   // symbol name from the NameField, e.g. "MyFunc"; empty if not extractable
	Parent   string   // containing symbol for nested nodes (e.g. class name for a method); empty for top-level
	Start    Position // start of the chunk in the source file (inclusive)
	End      Position // end of the chunk in the source file (inclusive)
}

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

type Config struct {
	MaxChunkSize int // split when a node exceeds this; default 1500
	MinChunkSize int // merge siblings until this is reached; default 50
}

type Edge struct {
	Kind            EdgeKind // relationship classification
	FilePath        string   // absolute path to the source file
	Language        string   // language name as reported by LanguageConfig.Name
	Source          string   // name of the enclosing definition; empty at file level (e.g. imports)
	SourceParent    string   // containing symbol of the enclosing definition (e.g. class name for a method); empty for top-level
	SourceLine      int      // 1-based start line of the enclosing definition; 0 when there is none
	Target          string   // referenced identifier, or module path for EdgeImport
	TargetQualifier string   // receiver/package part when qualified, or local alias for EdgeImport; empty otherwise
	Line            int      // 1-based line of the reference itself
}

type EdgeKind string

type EdgeRule struct {
	Kind           string   // AST node kind that triggers this rule, e.g. "call_expression"
	Edge           EdgeKind // edge kind to emit
	TargetField    string   // field holding the target expression; empty means the node's first named child
	QualifierField string   // field holding the receiver, for grammars that qualify on the node itself (e.g. Ruby's call)
	Descend        bool     // emit one edge per descendant whose kind is in EdgeRules.NameKinds
}

type EdgeRules struct {
	// Rules lists the node kinds that produce edges.
	Rules []EdgeRule

	// Qualified maps a qualified-name node kind to the fields that split it
	// into qualifier and name.
	Qualified map[string]QualifiedFields

	// NameKinds lists node kinds that count as a name when a rule descends,
	// e.g. "identifier", "type_identifier", "constant".
	NameKinds []string

	// ImportModuleKinds lists node kinds that carry an import's module text.
	// The first matching descendant of an import node wins. Surrounding
	// quotes and angle brackets are stripped from the result.
	ImportModuleKinds []string

	// ImportAliasKinds lists node kinds that carry an import's local alias,
	// searched among the import node's direct named children.
	ImportAliasKinds []string

	// CallNameEdges reclassifies calls to specific well-known names, for
	// languages that spell structural relationships as ordinary function calls:
	// Ruby's require and include, Bash's source, JavaScript's require.
	//
	// A call whose unqualified target matches a key emits the mapped edge kind
	// instead of [EdgeCall]. [EdgeImport] takes its target from the first
	// ImportModuleKinds descendant; any other kind takes one edge per NameKinds
	// descendant.
	CallNameEdges map[string]EdgeKind
}

type InjectionRule struct {
	ContainerKind string                    // node kind wrapping embedded content, e.g. "script_element"
	ContentKind   string                    // node kind of the raw content child, e.g. "raw_text"
	LangAttr      string                    // start_tag attribute that selects the grammar, e.g. "lang"
	DefaultLang   string                    // grammar key when LangAttr is absent, e.g. "javascript"
	Grammars      map[string]LanguageConfig // lang attribute value -> LanguageConfig
}

type LanguageConfig struct {
	Name       string           // canonical language name, e.g. "go", "python"
	Extensions []string         // file extensions including dot, e.g. [".go"], [".py", ".pyw"]
	Grammar    *sitter.Language // tree-sitter grammar; obtain via sitter.NewLanguage(binding.Language())
	NodeKinds  NodeKindSet
	Injections []InjectionRule // optional: re-parse embedded content with secondary grammars; nil means no injection
	Edges      EdgeRules       // optional: graph edge extraction for Analyze; zero value disables it
}

type NodeKindSet struct {
	TopLevel  []string // node types that become top-level chunk boundaries
	Nested    []string // node types nested inside top-level nodes (e.g. methods in a class)
	NameField string   // tree-sitter field name for the symbol identifier, e.g. "name"; empty means skip name extraction
}

type Position struct {
	Line       int // 1-based
	Column     int // 0-based
	ByteOffset int
}

type QualifiedFields struct {
	Qualifier string // field name holding the receiver/package part
	Name      string // field name holding the selected identifier
}