search

type Result struct {
    ID          int     // Post ID in index
    Title       string  // Post title
    Link        string  // Post URL
    Description string  // Short description
    Snippet     string  // Context snippet with highlighting
    Version     string  // Documentation version
    Score       float64 // BM25 relevance score
}

type Analyzer struct {
    useStopWords bool // Filter stop words
    useStemming  bool // Apply Porter stemming
}

type ParsedQuery struct {
    Terms   []string // Individual search terms
    Phrases []string // Quoted phrases
    Raw     string   // Original query
}

func PerformSearch(index *models.SearchIndex, query string, versionFilter string) []Result

import (
    "github.com/Kush-Singh-26/kosh/builder/search"
    "github.com/Kush-Singh-26/kosh/builder/models"
)

// Build index (done once during site build)
index := &models.SearchIndex{
    Posts: posts,
    Inverted: invertedIndex,
    TotalDocs: len(posts),
    AvgDocLen: avgDocLen,
    NgramIndex: ngramIndex,
}

// Perform search
results := search.PerformSearch(index, "architecture", "v4.0")
for _, r := range results {
    fmt.Printf("[%.2f] %s - %s\n", r.Score, r.Title, r.Snippet)
}

results := search.PerformSearch(index, "markdown parser", "all")
// Searches for posts containing "markdown" OR "parser" (stemmed)

results := search.PerformSearch(index, `"static site generator"`, "all")
// Exact phrase match (no stemming)

results := search.PerformSearch(index, "tag:architecture", "all")
// Only posts tagged with "architecture"

results := search.PerformSearch(index, "tag:api optimization", "all")
// Posts tagged "api" containing "optimization"

results := search.PerformSearch(index, "cache", "v4.0")
// Only search v4.0 documentation

results := search.PerformSearch(index, "cache", "all")
// Search all versions

func NewAnalyzer(useStopWords, useStemming bool) *Analyzer

// Default analyzer (stop words + stemming)
analyzer := search.DefaultAnalyzer
tokens := analyzer.Analyze("Running quickly through the forest")
// Returns: ["run", "quick", "forest"] (stemmed, stop words removed)

// Custom analyzer (no stemming)
analyzer := search.NewAnalyzer(true, false)
tokens := analyzer.Analyze("Running quickly through the forest")
// Returns: ["running", "quickly", "forest"] (original forms)

func TokenizeWithUnicode(text string) []string

tokens := search.TokenizeWithUnicode("Hello, 世界! How are you?")
// Returns: ["Hello", "世界", "How", "are", "you"]

func StemCached(word string) string

fmt.Println(search.StemCached("running"))   // "run"
fmt.Println(search.StemCached("flies"))     // "fli"
fmt.Println(search.StemCached("connected")) // "connect"
fmt.Println(search.StemCached("easily"))    // "easili"

func IsStopWord(word string) bool

fmt.Println(search.IsStopWord("the"))   // true
fmt.Println(search.IsStopWord("cache")) // false

a, an, and, are, as, at, be, but, by, for, if, in, into, is, it, no, not, of, on,
or, such, that, the, their, then, there, these, they, this, to, was, will, with, ...

func LevenshteinDistance(a, b string) int

fmt.Println(search.LevenshteinDistance("cache", "cach"))   // 1 (1 deletion)
fmt.Println(search.LevenshteinDistance("cache", "cahe"))   // 1 (1 substitution)
fmt.Println(search.LevenshteinDistance("cache", "caxhe"))  // 1 (1 substitution)
fmt.Println(search.LevenshteinDistance("cache", "parse"))  // 3 (3 substitutions)

func FuzzyMatch(term, target string, maxDist int) bool

fmt.Println(search.FuzzyMatch("trnsformer", "transformer", 2)) // true (1 insertion)
fmt.Println(search.FuzzyMatch("seach", "search", 2))           // true (1 insertion)
fmt.Println(search.FuzzyMatch("xyz", "search", 2))             // false (too different)

func BuildNgramIndex(inverted map[string]map[int]int) map[string][]string

inverted := map[string]map[int]int{
    "cache": {1: 5, 2: 3},
    "search": {3: 8},
}

ngramIndex := search.BuildNgramIndex(inverted)
// ngramIndex["cac"] = ["cache"]
// ngramIndex["ach"] = ["cache"]
// ngramIndex["che"] = ["cache"]
// ngramIndex["sea"] = ["search"]
// etc.

// Use for fast fuzzy expansion
candidates := search.FuzzyExpandWithNgrams("cach", ngramIndex, 2)
// Returns: ["cache"] (fast candidate lookup)

func ParseQuery(query string) ParsedQuery

parsed := search.ParseQuery(`architecture "static site generator" performance`)

fmt.Println(parsed.Terms)   // ["architectur", "perform"] (stemmed)
fmt.Println(parsed.Phrases) // ["static site generator"] (exact)
fmt.Println(parsed.Raw)     // Original query

func ExtractSnippet(content string, terms []string) string

content := "The cache system uses BoltDB for persistent storage and BLAKE3 for content hashing."
terms := []string{"cache", "blake3"}

snippet := search.ExtractSnippet(content, terms)
// Returns: "...The <b>cache</b> system uses BoltDB for persistent storage and <b>BLAKE3</b> for content hashing."

const (
    MaxSnippetContentLength = 10000 // Max content to process
    DefaultSnippetLength    = 150   // Default snippet length
    SnippetContextBefore    = 60    // Characters before match
    SnippetContextAfter     = 90    // Characters after match
)

BM25(q, d) = Σ IDF(qi) × (f(qi, d) × (k1 + 1)) / (f(qi, d) + k1 × (1 - b + b × |d| / avgdl))

Where:
- IDF(qi) = log((N - df + 0.5) / (df + 0.5) + 1)
- f(qi, d) = term frequency in document
- |d| = document length
- avgdl = average document length
- k1 = 1.2 (term saturation parameter)
- b = 0.75 (length normalization parameter)
- N = total documents
- df = document frequency for term

const (
    ScorePhraseMatch   = 15.0 // Phrase match boost
    ScoreTitleMatch    = 10.0 // Title match boost
    ScoreTagMatch      = 5.0  // Tag match boost
    ScoreFuzzyModifier = 0.7  // Fuzzy match penalty
)

Term match:        BM25 score (0.0 - 10.0)
Phrase match:      +15.0
Title match:       +10.0
Tag match:         +5.0
Fuzzy match:       ×0.7 penalty

var stemCache sync.Map // Thread-safe cache

func StemCached(word string) string {
    if cached, ok := stemCache.Load(word); ok {
        return cached.(string)
    }
    stemmed := stem(word)
    stemCache.Store(word, stemmed)
    return stemmed
}

var (
    replacerCache   = make(map[string]*strings.Replacer)
    replacerCacheMu sync.RWMutex
)

func getReplacer(term string) *strings.Replacer {
    replacerCacheMu.RLock()
    if r, ok := replacerCache[term]; ok {
        replacerCacheMu.RUnlock()
        return r
    }
    replacerCacheMu.RUnlock()
    // Build and cache replacer
}

postCache := make(map[int]*models.PostRecord, maxResults)

for postID, freq := range posts {
    post, cached := postCache[postID]
    if !cached {
        post = &index.Posts[postID]
        postCache[postID] = post
    }
    // Use cached post
}

import (
    "github.com/Kush-Singh-26/kosh/builder/search"
    "github.com/Kush-Singh-26/kosh/builder/models"
)

// Create inverted index
inverted := make(map[string]map[int]int)
analyzer := search.DefaultAnalyzer

for i, post := range posts {
    tokens := analyzer.Analyze(post.Content)
    for _, token := range tokens {
        if inverted[token] == nil {
            inverted[token] = make(map[int]int)
        }
        inverted[token][i]++ // Term frequency
    }
}

// Build trigram index
ngramIndex := search.BuildNgramIndex(inverted)

// Create search index
index := &models.SearchIndex{
    Posts: posts,
    Inverted: inverted,
    NgramIndex: ngramIndex,
    TotalDocs: len(posts),
    AvgDocLen: calculateAvgDocLen(posts),
}

GOOS=js GOARCH=wasm go build -o search.wasm ./cmd/search

const go = new Go();
WebAssembly.instantiateStreaming(fetch("search.wasm"), go.importObject)
    .then((result) => {
        go.run(result.instance);
        
        // Search function exposed from Go
        const results = window.performSearch("architecture", "all");
        console.log(results);
    });