chore: import upstream snapshot with attribution

internal/parser/languages/orgmode.go

@@ -0,0 +1,298 @@
+package languages
+
+import (
+	"fmt"
+	"regexp"
+	"strings"
+
+	"github.com/zzet/gortex/internal/graph"
+	"github.com/zzet/gortex/internal/parser"
+	sitter "github.com/zzet/gortex/internal/parser/tsitter"
+	tree_sitter_orgmode "github.com/zzet/gortex/internal/parser/tsitter/orgmode"
+)
+
+// headingPattern matches an Org headline: stars, optional TODO/DONE keyword,
+// optional priority cookie, optional COMMENT, and the remaining title text.
+var headingPattern = regexp.MustCompile(
+	`^(\*+)\s+(?:(TODO|DONE)\s+)?(?:(\[#[A-Za-z0-9]\])\s+)?(?:(COMMENT)\s*)?(.*?)\s*$`,
+)
+
+// keywordKeyPattern strips the leading `#+` and trailing `:` from a
+// keyword_key node so we can match against canonical names like TITLE.
+var keywordKeyPattern = regexp.MustCompile(`^#\+(.+?):?$`)
+
+// OrgModeExtractor extracts Org-mode document structure: headlines (with
+// TODO state and priority cookies), greater blocks (BEGIN_SRC, BEGIN_QUOTE,
+// ...), file-level keywords (#+TITLE, #+AUTHOR, ...), and intra-repo links.
+type OrgModeExtractor struct {
+	lang *sitter.Language
+}
+
+func NewOrgModeExtractor() *OrgModeExtractor {
+	return &OrgModeExtractor{lang: tree_sitter_orgmode.GetLanguage()}
+}
+
+func (e *OrgModeExtractor) Language() string     { return "orgmode" }
+func (e *OrgModeExtractor) Extensions() []string { return []string{".org"} }
+
+func (e *OrgModeExtractor) Extract(filePath string, src []byte) (*parser.ExtractionResult, error) {
+	// Upstream grammar fails to recognize a level-1 heading when the file
+	// starts at byte 0 with `*`. Prepend a newline and shift row numbers
+	// back by one when emitting graph positions.
+	rowOffset := 0
+	parseSrc := src
+	if len(src) == 0 || src[0] != '\n' {
+		parseSrc = append([]byte{'\n'}, src...)
+		rowOffset = 1
+	}
+
+	tree, err := parser.ParseFile(parseSrc, e.lang)
+	if err != nil {
+		return nil, err
+	}
+	defer tree.Close()
+
+	root := tree.RootNode()
+	result := &parser.ExtractionResult{}
+
+	endRow := max(int(root.EndPoint().Row)-rowOffset, 0)
+	fileNode := &graph.Node{
+		ID: filePath, Kind: graph.KindFile, Name: filePath,
+		FilePath: filePath, StartLine: 1, EndLine: endRow + 1,
+		Language: "orgmode",
+	}
+	result.Nodes = append(result.Nodes, fileNode)
+
+	seen := make(map[string]bool)
+	seenLinks := make(map[string]bool)
+
+	startLine := func(n *sitter.Node) int {
+		return max(int(n.StartPoint().Row)-rowOffset, 0) + 1
+	}
+	endLine := func(n *sitter.Node) int {
+		return max(int(n.EndPoint().Row)-rowOffset, 0) + 1
+	}
+
+	var walk func(node *sitter.Node)
+	walk = func(node *sitter.Node) {
+		switch node.Type() {
+		case "heading":
+			e.extractHeading(node, parseSrc, filePath, fileNode.ID, seen, result, startLine, endLine)
+		case "greater_block":
+			e.extractBlock(node, parseSrc, filePath, fileNode.ID, seen, result, startLine, endLine)
+		case "keyword":
+			// Top-level #+KEY: VALUE. Stash #+TITLE on the file node.
+			e.maybeAttachKeyword(node, parseSrc, fileNode)
+		case "regular_link":
+			e.extractLink(node, parseSrc, filePath, fileNode.ID, seenLinks, result, startLine)
+		}
+		for i, _nc := 0, int(node.NamedChildCount()); i < _nc; i++ {
+			walk(node.NamedChild(i))
+		}
+	}
+	walk(root)
+
+	return result, nil
+}
+
+// extractHeading parses an Org headline from its raw text. The grammar
+// exposes only the `stars` node as a named child — TODO/priority/title come
+// from anonymous string aliases and aren't accessible as nodes — so we apply
+// a regex to the line itself.
+func (e *OrgModeExtractor) extractHeading(
+	node *sitter.Node, src []byte, filePath, fileID string,
+	seen map[string]bool, result *parser.ExtractionResult,
+	startLine, endLine func(*sitter.Node) int,
+) {
+	// Heading content includes trailing whitespace / newline. Trim and take
+	// the first line — the headline is always single-line.
+	raw := node.Content(src)
+	if i := strings.IndexByte(raw, '\n'); i >= 0 {
+		raw = raw[:i]
+	}
+	raw = strings.TrimRight(raw, " \t")
+
+	m := headingPattern.FindStringSubmatch(raw)
+	if m == nil {
+		return
+	}
+	level := len(m[1])
+	todo := m[2]
+	priority := m[3]
+	isComment := m[4] == "COMMENT"
+	title := strings.TrimSpace(m[5])
+
+	if level == 0 {
+		return
+	}
+	if title == "" && !isComment {
+		// A bare `*` line with nothing after it isn't a useful node.
+		return
+	}
+	displayName := title
+	if displayName == "" {
+		displayName = "(comment)"
+	}
+
+	id := fmt.Sprintf("%s::h%d:%s", filePath, level, displayName)
+	if seen[id] {
+		return
+	}
+	seen[id] = true
+
+	meta := map[string]any{"heading_level": level}
+	if todo != "" {
+		meta["todo_state"] = todo
+	}
+	if priority != "" {
+		meta["priority"] = priority
+	}
+	if isComment {
+		meta["comment"] = true
+	}
+
+	result.Nodes = append(result.Nodes, &graph.Node{
+		ID: id, Kind: graph.KindVariable, Name: displayName,
+		FilePath: filePath, StartLine: startLine(node), EndLine: endLine(node),
+		Language: "orgmode", Meta: meta,
+	})
+	result.Edges = append(result.Edges, &graph.Edge{
+		From: fileID, To: id, Kind: graph.EdgeDefines,
+		FilePath: filePath, Line: startLine(node),
+	})
+}
+
+// extractBlock handles #+BEGIN_X ... #+END_X greater blocks. SRC blocks
+// record the source language from the begin-line parameters.
+func (e *OrgModeExtractor) extractBlock(
+	node *sitter.Node, src []byte, filePath, fileID string,
+	seen map[string]bool, result *parser.ExtractionResult,
+	startLine, endLine func(*sitter.Node) int,
+) {
+	var blockType, params string
+	for i, _nc := 0, int(node.NamedChildCount()); i < _nc; i++ {
+		child := node.NamedChild(i)
+		switch child.Type() {
+		case "block_begin_name":
+			blockType = strings.ToLower(strings.TrimSpace(child.Content(src)))
+		case "value":
+			if params == "" {
+				params = strings.TrimSpace(child.Content(src))
+			}
+		}
+	}
+	if blockType == "" {
+		return
+	}
+
+	displayName := blockType + " block"
+	meta := map[string]any{"block_type": blockType}
+	if blockType == "src" && params != "" {
+		// First whitespace-separated token is the source language.
+		lang := params
+		if i := strings.IndexAny(lang, " \t"); i > 0 {
+			lang = lang[:i]
+		}
+		if lang != "" {
+			meta["code_language"] = lang
+			displayName = lang + " code block"
+		}
+	}
+
+	sLine := startLine(node)
+	id := fmt.Sprintf("%s::block:%s:%d", filePath, blockType, sLine)
+	if seen[id] {
+		return
+	}
+	seen[id] = true
+
+	result.Nodes = append(result.Nodes, &graph.Node{
+		ID: id, Kind: graph.KindVariable, Name: displayName,
+		FilePath: filePath, StartLine: sLine, EndLine: endLine(node),
+		Language: "orgmode", Meta: meta,
+	})
+	result.Edges = append(result.Edges, &graph.Edge{
+		From: fileID, To: id, Kind: graph.EdgeDefines,
+		FilePath: filePath, Line: sLine,
+	})
+}
+
+// maybeAttachKeyword stores #+TITLE: ... and #+AUTHOR: ... on the file node
+// so consumers can show the document title without re-parsing.
+func (e *OrgModeExtractor) maybeAttachKeyword(node *sitter.Node, src []byte, fileNode *graph.Node) {
+	var rawKey, val string
+	for i, _nc := 0, int(node.NamedChildCount()); i < _nc; i++ {
+		child := node.NamedChild(i)
+		switch child.Type() {
+		case "keyword_key":
+			rawKey = strings.TrimSpace(child.Content(src))
+		case "value":
+			val = strings.TrimSpace(child.Content(src))
+		}
+	}
+	if rawKey == "" || val == "" {
+		return
+	}
+	m := keywordKeyPattern.FindStringSubmatch(rawKey)
+	if m == nil {
+		return
+	}
+	key := strings.ToUpper(m[1])
+	switch key {
+	case "TITLE", "AUTHOR":
+		if fileNode.Meta == nil {
+			fileNode.Meta = map[string]any{}
+		}
+		fileNode.Meta[strings.ToLower(key)] = val
+	}
+}
+
+// extractLink emits an EdgeImports for intra-repo Org links.
+// Skips http/https/mailto/anchor links — only file-style targets become edges.
+func (e *OrgModeExtractor) extractLink(
+	node *sitter.Node, src []byte, filePath, fileID string,
+	seen map[string]bool, result *parser.ExtractionResult,
+	startLine func(*sitter.Node) int,
+) {
+	var target string
+	for i, _nc := 0, int(node.NamedChildCount()); i < _nc; i++ {
+		child := node.NamedChild(i)
+		if child.Type() == "pathreg" {
+			target = strings.TrimSpace(child.Content(src))
+			break
+		}
+	}
+	if target == "" {
+		return
+	}
+
+	// Strip the optional "file:" prefix that Org uses for explicit file links.
+	target = strings.TrimPrefix(target, "file:")
+
+	// Skip non-file schemes and pure anchors.
+	for _, prefix := range []string{"http://", "https://", "mailto:", "ftp://", "news:", "elisp:", "shell:", "id:", "#", "*"} {
+		if strings.HasPrefix(target, prefix) {
+			return
+		}
+	}
+
+	// Strip an inline anchor: "foo.org::*Heading" or "foo.org#anchor".
+	for _, sep := range []string{"::", "#"} {
+		if i := strings.Index(target, sep); i > 0 {
+			target = target[:i]
+			break
+		}
+	}
+
+	if target == "" || seen[target] {
+		return
+	}
+	seen[target] = true
+
+	result.Edges = append(result.Edges, &graph.Edge{
+		From: fileID, To: "unresolved::import::" + target,
+		Kind: graph.EdgeImports, FilePath: filePath, Line: startLine(node),
+	})
+}
+
+var _ parser.Extractor = (*OrgModeExtractor)(nil)