@peaske7/readit 0.2.1 → 0.3.0-rc.1

package/go/internal/server/anchor.go

@@ -1,302 +0,0 @@
-package server
-
-import (
-	"fmt"
-	"regexp"
-	"strings"
-	"unicode/utf8"
-)
-
-var lineHintRe = regexp.MustCompile(`^L(\d+)(?:-L?(\d+))?$`)
-
-type AnchorResult struct {
-	StartOffset int
-	EndOffset   int
-	Confidence  string
-}
-
-func ParseLineHint(hint string) (start, end int) {
-	m := lineHintRe.FindStringSubmatch(hint)
-	if m == nil {
-		return 1, 1
-	}
-	_, _ = fmt.Sscanf(m[1], "%d", &start)
-	if m[2] != "" {
-		_, _ = fmt.Sscanf(m[2], "%d", &end)
-	} else {
-		end = start
-	}
-	return
-}
-
-// lineOffset returns the byte offset of the start of the given 1-indexed line.
-func lineOffset(content string, line int) int {
-	if line <= 1 {
-		return 0
-	}
-	n := 0
-	for i, c := range content {
-		if c == '\n' {
-			n++
-			if n == line-1 {
-				return i + 1
-			}
-		}
-	}
-	return len(content)
-}
-
-func FindAnchor(source, selectedText, lineHint string) *AnchorResult {
-	if selectedText == "" {
-		return nil
-	}
-
-	// Try exact match near hint first
-	hintLine, _ := ParseLineHint(lineHint)
-	offset := lineOffset(source, hintLine)
-
-	windowStart := max(0, offset-DefaultSearchWindow)
-	windowEnd := min(len(source), offset+DefaultSearchWindow)
-	window := source[windowStart:windowEnd]
-
-	if idx := strings.Index(window, selectedText); idx >= 0 {
-		start := windowStart + idx
-		return &AnchorResult{
-			StartOffset: start,
-			EndOffset:   start + len(selectedText),
-			Confidence:  AnchorExact,
-		}
-	}
-
-	// Fall back to full source
-	if idx := strings.Index(source, selectedText); idx >= 0 {
-		return &AnchorResult{
-			StartOffset: idx,
-			EndOffset:   idx + len(selectedText),
-			Confidence:  AnchorExact,
-		}
-	}
-
-	return nil
-}
-
-func normalizeWhitespace(s string) string {
-	var b strings.Builder
-	inSpace := false
-	for _, r := range s {
-		if r == ' ' || r == '\t' || r == '\n' || r == '\r' {
-			if !inSpace {
-				b.WriteByte(' ')
-				inSpace = true
-			}
-		} else {
-			b.WriteRune(r)
-			inSpace = false
-		}
-	}
-	return strings.TrimSpace(b.String())
-}
-
-func FindAnchorNormalized(source, selectedText, lineHint string) *AnchorResult {
-	normText := normalizeWhitespace(selectedText)
-	normSource := normalizeWhitespace(source)
-	if normText == selectedText && normSource == source {
-		return nil // no normalization needed
-	}
-
-	// Try windowed search near the hint first
-	hintLine, _ := ParseLineHint(lineHint)
-	offset := lineOffset(source, hintLine)
-	normCharOffset := mapSourceToNormCharOffset(source, offset)
-
-	normRunes := []rune(normSource)
-	normTextRunes := []rune(normText)
-	normTextRuneLen := len(normTextRunes)
-
-	windowStart := max(0, normCharOffset-DefaultSearchWindow)
-	windowEnd := min(len(normRunes), normCharOffset+DefaultSearchWindow)
-	window := string(normRunes[windowStart:windowEnd])
-
-	if before, _, ok := strings.Cut(window, normText); ok {
-		charIdx := utf8.RuneCountInString(before)
-		return resolveNormalizedMatch(source, windowStart+charIdx, normTextRuneLen)
-	}
-
-	// Fall back to full source
-	if before, _, ok := strings.Cut(normSource, normText); ok {
-		charIdx := utf8.RuneCountInString(before)
-		return resolveNormalizedMatch(source, charIdx, normTextRuneLen)
-	}
-
-	return nil
-}
-
-func resolveNormalizedMatch(source string, normCharIdx int, normTextRuneLen int) *AnchorResult {
-	origStart := mapNormalizedCharOffset(source, normCharIdx)
-	origEnd := mapNormalizedCharOffset(source, normCharIdx+normTextRuneLen)
-
-	// Trim trailing whitespace at end position
-	for origEnd > origStart && origEnd < len(source) {
-		if c := source[origEnd-1]; c == ' ' || c == '\t' || c == '\n' || c == '\r' {
-			origEnd--
-		} else {
-			break
-		}
-	}
-
-	return &AnchorResult{
-		StartOffset: origStart,
-		EndOffset:   origEnd,
-		Confidence:  AnchorNormalized,
-	}
-}
-
-func mapSourceToNormCharOffset(original string, sourceOffset int) int {
-	normPos := 0
-	inSpace := false
-	for i, r := range original {
-		if i >= sourceOffset {
-			return normPos
-		}
-		if r == ' ' || r == '\t' || r == '\n' || r == '\r' {
-			if !inSpace {
-				normPos++
-				inSpace = true
-			}
-		} else {
-			normPos++
-			inSpace = false
-		}
-	}
-	return normPos
-}
-
-func mapNormalizedCharOffset(original string, normCharOffset int) int {
-	normPos := 0
-	inSpace := false
-	for i, r := range original {
-		if normPos >= normCharOffset {
-			return i
-		}
-		if r == ' ' || r == '\t' || r == '\n' || r == '\r' {
-			if !inSpace {
-				normPos++
-				inSpace = true
-			}
-		} else {
-			normPos++
-			inSpace = false
-		}
-	}
-	return len(original)
-}
-
-func FindAnchorFuzzy(source, selectedText, lineHint string) *AnchorResult {
-	selectedRunes := []rune(selectedText)
-	if len(selectedRunes) > MaxFuzzyTextLength {
-		return nil
-	}
-
-	hintLine, _ := ParseLineHint(lineHint)
-	offset := lineOffset(source, hintLine)
-
-	windowStart := max(0, offset-FuzzySearchWindow)
-	windowEnd := min(len(source), offset+FuzzySearchWindow)
-	window := source[windowStart:windowEnd]
-
-	windowRunes := []rune(window)
-	textRuneLen := len(selectedRunes)
-	threshold := DefaultFuzzyThreshold
-
-	bestDist := threshold + 1
-	bestStart := -1
-	bestEnd := -1
-
-	for i := 0; i <= len(windowRunes)-textRuneLen+threshold; i++ {
-		for candLen := max(1, textRuneLen-threshold); candLen <= min(len(windowRunes)-i, textRuneLen+threshold); candLen++ {
-			candidate := windowRunes[i : i+candLen]
-			dist := levenshteinRunes(selectedRunes, candidate, threshold)
-			if dist <= threshold && dist < bestDist {
-				bestDist = dist
-				// Convert rune indices back to byte offsets
-				byteStart := len(string(windowRunes[:i]))
-				byteEnd := len(string(windowRunes[:i+candLen]))
-				bestStart = windowStart + byteStart
-				bestEnd = windowStart + byteEnd
-			}
-		}
-	}
-
-	if bestStart < 0 {
-		return nil
-	}
-
-	return &AnchorResult{
-		StartOffset: bestStart,
-		EndOffset:   bestEnd,
-		Confidence:  AnchorFuzzy,
-	}
-}
-
-func levenshteinRunes(a, b []rune, maxDist int) int {
-	la, lb := len(a), len(b)
-	if abs(la-lb) > maxDist {
-		return maxDist + 1
-	}
-
-	if la > lb {
-		a, b = b, a
-		la, lb = lb, la
-	}
-
-	prev := make([]int, la+1)
-	curr := make([]int, la+1)
-
-	for i := range prev {
-		prev[i] = i
-	}
-
-	for j := 1; j <= lb; j++ {
-		curr[0] = j
-		minVal := curr[0]
-		for i := 1; i <= la; i++ {
-			cost := 1
-			if a[i-1] == b[j-1] {
-				cost = 0
-			}
-			curr[i] = min(
-				prev[i]+1,
-				min(curr[i-1]+1, prev[i-1]+cost),
-			)
-			if curr[i] < minVal {
-				minVal = curr[i]
-			}
-		}
-		if minVal > maxDist {
-			return maxDist + 1
-		}
-		prev, curr = curr, prev
-	}
-
-	return prev[la]
-}
-
-func abs(x int) int {
-	if x < 0 {
-		return -x
-	}
-	return x
-}
-
-func FindAnchorWithFallback(source, selectedText, lineHint string) *AnchorResult {
-	if r := FindAnchor(source, selectedText, lineHint); r != nil {
-		return r
-	}
-	if r := FindAnchorNormalized(source, selectedText, lineHint); r != nil {
-		return r
-	}
-	if r := FindAnchorFuzzy(source, selectedText, lineHint); r != nil {
-		return r
-	}
-	return nil
-}

package/go/internal/server/anchor_test.go

@@ -1,111 +0,0 @@
-package server
-
-import "testing"
-
-func TestParseLineHint(t *testing.T) {
-	tests := []struct {
-		input     string
-		wantStart int
-		wantEnd   int
-	}{
-		{"L42", 42, 42},
-		{"L42-L55", 42, 55},
-		{"L42-55", 42, 55}, // legacy format
-		{"invalid", 1, 1},
-	}
-
-	for _, tt := range tests {
-		s, e := ParseLineHint(tt.input)
-		if s != tt.wantStart || e != tt.wantEnd {
-			t.Errorf("ParseLineHint(%q) = (%d, %d), want (%d, %d)", tt.input, s, e, tt.wantStart, tt.wantEnd)
-		}
-	}
-}
-
-func TestFindAnchorExact(t *testing.T) {
-	source := "line1\nline2\nthe target text\nline4"
-	result := FindAnchor(source, "the target text", "L3")
-	if result == nil {
-		t.Fatal("expected match")
-	}
-	if result.Confidence != AnchorExact {
-		t.Errorf("confidence = %q, want exact", result.Confidence)
-	}
-	if source[result.StartOffset:result.EndOffset] != "the target text" {
-		t.Errorf("matched text = %q", source[result.StartOffset:result.EndOffset])
-	}
-}
-
-func TestFindAnchorExactFullScan(t *testing.T) {
-	source := "line1\nline2\nline3\nline4\nline5\nline6\nline7\nline8\nline9\nline10\nfar away target"
-	result := FindAnchor(source, "far away target", "L1")
-	if result == nil {
-		t.Fatal("expected match via full scan")
-	}
-	if result.Confidence != AnchorExact {
-		t.Errorf("confidence = %q, want exact", result.Confidence)
-	}
-}
-
-func TestFindAnchorNormalized(t *testing.T) {
-	source := "hello   world\nfoo"
-	result := FindAnchorNormalized(source, "hello world", "L1")
-	if result == nil {
-		t.Fatal("expected normalized match")
-	}
-	if result.Confidence != AnchorNormalized {
-		t.Errorf("confidence = %q, want normalized", result.Confidence)
-	}
-}
-
-func TestFindAnchorNormalizedSkipsSame(t *testing.T) {
-	source := "hello world"
-	result := FindAnchorNormalized(source, "hello world", "L1")
-	if result != nil {
-		t.Error("should return nil when both source and text already normalized")
-	}
-}
-
-func TestFindAnchorFuzzy(t *testing.T) {
-	source := "the quick brwon fox jumps"
-	result := FindAnchorFuzzy(source, "the quick brown fox jumps", "L1")
-	if result == nil {
-		t.Fatal("expected fuzzy match")
-	}
-	if result.Confidence != AnchorFuzzy {
-		t.Errorf("confidence = %q, want fuzzy", result.Confidence)
-	}
-}
-
-func TestFindAnchorFuzzyTooLong(t *testing.T) {
-	long := make([]byte, MaxFuzzyTextLength+1)
-	for i := range long {
-		long[i] = 'a'
-	}
-	result := FindAnchorFuzzy("aaaa", string(long), "L1")
-	if result != nil {
-		t.Error("should return nil for text exceeding MaxFuzzyTextLength")
-	}
-}
-
-func TestFindAnchorWithFallback(t *testing.T) {
-	source := "line1\nhello   world\nline3"
-
-	// Exact match
-	r := FindAnchorWithFallback(source, "hello   world", "L2")
-	if r == nil || r.Confidence != AnchorExact {
-		t.Error("expected exact match")
-	}
-
-	// Normalized fallback
-	r = FindAnchorWithFallback(source, "hello world", "L2")
-	if r == nil || r.Confidence != AnchorNormalized {
-		t.Errorf("expected normalized match, got %v", r)
-	}
-
-	// No match
-	r = FindAnchorWithFallback(source, "nonexistent text that does not appear anywhere at all", "L1")
-	if r != nil {
-		t.Error("expected nil for non-matching text")
-	}
-}