@comfanion/usethis_search 0.1.5 → 3.0.0-dev.0

package/vectorizer/chunkers/markdown-chunker.ts

@@ -0,0 +1,177 @@
+/**
+ * Markdown Chunker — splits Markdown by heading structure.
+ *
+ * Preserves heading hierarchy ("API > Auth > JWT") in metadata,
+ * merges small sections, and splits oversized ones.
+ */
+
+export interface MarkdownChunkConfig {
+  min_chunk_size: number   // merge sections smaller than this (chars)
+  max_chunk_size: number   // split sections larger than this (chars)
+  split_by_headings: boolean
+  preserve_heading_hierarchy: boolean
+}
+
+export const DEFAULT_MD_CONFIG: MarkdownChunkConfig = {
+  min_chunk_size: 200,
+  max_chunk_size: 2000,
+  split_by_headings: true,
+  preserve_heading_hierarchy: true,
+}
+
+export interface MarkdownChunk {
+  content: string
+  heading_context: string   // "H1 > H2 > H3"
+}
+
+// ── Internal types ──────────────────────────────────────────────────────────
+
+interface Section {
+  level: number       // 1-6 for headings, 0 for preamble
+  heading: string
+  body: string
+}
+
+// ── Parsing ─────────────────────────────────────────────────────────────────
+
+/** Parse Markdown into sections keyed by heading. */
+function parseSections(content: string): Section[] {
+  const lines = content.split("\n")
+  const sections: Section[] = []
+  let currentSection: Section = { level: 0, heading: "", body: "" }
+
+  for (const line of lines) {
+    const headingMatch = line.match(/^(#{1,6})\s+(.+)$/)
+    if (headingMatch) {
+      // Push previous section
+      if (currentSection.body.trim() || currentSection.heading) {
+        sections.push(currentSection)
+      }
+      currentSection = {
+        level: headingMatch[1].length,
+        heading: headingMatch[2].trim(),
+        body: "",
+      }
+    } else {
+      currentSection.body += line + "\n"
+    }
+  }
+
+  // Push last section
+  if (currentSection.body.trim() || currentSection.heading) {
+    sections.push(currentSection)
+  }
+
+  return sections
+}
+
+/** Build heading hierarchy path for a section given the heading stack. */
+function buildHeadingContext(stack: { level: number; heading: string }[]): string {
+  return stack.map((h) => h.heading).join(" > ")
+}
+
+// ── Splitting oversized sections ────────────────────────────────────────────
+
+function splitLargeText(text: string, maxSize: number): string[] {
+  if (text.length <= maxSize) return [text]
+
+  const chunks: string[] = []
+  const lines = text.split("\n")
+  let current: string[] = []
+  let currentLen = 0
+
+  for (const line of lines) {
+    if (currentLen + line.length + 1 > maxSize && current.length > 0) {
+      chunks.push(current.join("\n"))
+      current = []
+      currentLen = 0
+    }
+    current.push(line)
+    currentLen += line.length + 1
+  }
+
+  if (current.length > 0) {
+    chunks.push(current.join("\n"))
+  }
+
+  return chunks
+}
+
+// ── Public API ──────────────────────────────────────────────────────────────
+
+/**
+ * Chunk Markdown content into semantic sections.
+ */
+export function chunkMarkdown(
+  content: string,
+  config: MarkdownChunkConfig = DEFAULT_MD_CONFIG,
+): MarkdownChunk[] {
+  if (!config.split_by_headings) {
+    // Fallback: single chunk (caller can use fixed chunker)
+    return [{ content, heading_context: "" }]
+  }
+
+  const sections = parseSections(content)
+  const rawChunks: MarkdownChunk[] = []
+
+  // Heading stack for hierarchy tracking
+  const headingStack: { level: number; heading: string }[] = []
+
+  for (const section of sections) {
+    // Update heading stack
+    if (section.level > 0) {
+      // Pop headings at same or deeper level
+      while (
+        headingStack.length > 0 &&
+        headingStack[headingStack.length - 1].level >= section.level
+      ) {
+        headingStack.pop()
+      }
+      headingStack.push({ level: section.level, heading: section.heading })
+    }
+
+    const headingContext = config.preserve_heading_hierarchy
+      ? buildHeadingContext(headingStack)
+      : section.heading
+
+    const sectionText = section.heading
+      ? `${"#".repeat(section.level)} ${section.heading}\n${section.body}`
+      : section.body
+
+    rawChunks.push({ content: sectionText.trim(), heading_context: headingContext })
+  }
+
+  // Merge small sections with previous
+  const merged: MarkdownChunk[] = []
+  for (const chunk of rawChunks) {
+    if (
+      merged.length > 0 &&
+      chunk.content.length < config.min_chunk_size
+    ) {
+      const prev = merged[merged.length - 1]
+      prev.content += "\n\n" + chunk.content
+      // Keep the deepest heading context
+      if (chunk.heading_context) {
+        prev.heading_context = chunk.heading_context
+      }
+    } else {
+      merged.push({ ...chunk })
+    }
+  }
+
+  // Split oversized sections
+  const result: MarkdownChunk[] = []
+  for (const chunk of merged) {
+    if (chunk.content.length > config.max_chunk_size) {
+      const parts = splitLargeText(chunk.content, config.max_chunk_size)
+      for (const part of parts) {
+        result.push({ content: part, heading_context: chunk.heading_context })
+      }
+    } else {
+      result.push(chunk)
+    }
+  }
+
+  // Filter empties
+  return result.filter((c) => c.content.trim().length > 0)
+}

package/vectorizer/content-cleaner.ts

@@ -0,0 +1,136 @@
+/**
+ * Content Cleaner — removes noise from file content before chunking.
+ *
+ * Strips TOC blocks, breadcrumbs, repeated headers, auto-generated markers,
+ * and optionally imports/comments so the embedding model sees only signal.
+ */
+
+export interface CleaningConfig {
+  remove_toc: boolean
+  remove_frontmatter_metadata: boolean
+  remove_imports: boolean
+  remove_comments: boolean
+}
+
+export const DEFAULT_CLEANING_CONFIG: CleaningConfig = {
+  remove_toc: true,
+  remove_frontmatter_metadata: false,
+  remove_imports: false,
+  remove_comments: false,
+}
+
+// ── Markdown noise ──────────────────────────────────────────────────────────
+
+/** Remove YAML front-matter (---…---) from Markdown. */
+function stripFrontmatter(text: string): string {
+  return text.replace(/^---\n[\s\S]*?\n---\n?/, "")
+}
+
+/**
+ * Remove inline TOC blocks.
+ * Matches patterns like:
+ *   ## Table of Contents
+ *   - [Section](#section)
+ *   …blank line
+ */
+function stripToc(text: string): string {
+  // Pattern: heading containing "table of contents" or "contents" followed by link-list
+  return text.replace(
+    /^#{1,3}\s*(Table of Contents|Contents|TOC)\s*\n([\t ]*[-*]\s*\[.*?\]\(#.*?\)\s*\n?)+/gim,
+    "",
+  )
+}
+
+/** Remove HTML-style TOC markers like <!-- TOC --> … <!-- /TOC --> */
+function stripHtmlTocMarkers(text: string): string {
+  return text.replace(/<!--\s*TOC\s*-->[\s\S]*?<!--\s*\/TOC\s*-->\n?/gi, "")
+}
+
+/** Remove breadcrumb lines, e.g. `Home > Docs > API` at the top. */
+function stripBreadcrumbs(text: string): string {
+  // Matches lines that look like breadcrumbs (word > word > word) at start
+  return text.replace(/^(?:[\w\s]+>\s*){2,}[\w\s]+\n{1,2}/gm, "")
+}
+
+/** Remove auto-generated code markers like `// AUTO-GENERATED` blocks. */
+function stripAutoGenMarkers(text: string): string {
+  return text.replace(
+    /\/[/*]\s*(?:AUTO[- ]?GENERATED|DO NOT (?:EDIT|MODIFY)|GENERATED BY|This file (?:is|was) (?:auto-?)?generated)[^\n]*/gi,
+    "",
+  )
+}
+
+// ── Code noise ──────────────────────────────────────────────────────────────
+
+/** Remove import/require statements (JS/TS/Python/Go). */
+function stripImports(text: string): string {
+  // JS/TS imports
+  let result = text.replace(/^import\s[\s\S]*?from\s+['"][^'"]+['"];?\s*$/gm, "")
+  result = result.replace(/^import\s+['"][^'"]+['"];?\s*$/gm, "")
+  // require
+  result = result.replace(/^(?:const|let|var)\s+.*?=\s*require\s*\(.*?\);?\s*$/gm, "")
+  // Python
+  result = result.replace(/^(?:from\s+\S+\s+)?import\s+.+$/gm, "")
+  // Go
+  result = result.replace(/^import\s*\(\s*\n(?:[\t ]*"[^"]*"\s*\n?)*\s*\)/gm, "")
+  result = result.replace(/^import\s+"[^"]*"\s*$/gm, "")
+  return result
+}
+
+/** Remove single-line and block comments (JS/TS style). */
+function stripComments(text: string): string {
+  // Block comments
+  let result = text.replace(/\/\*[\s\S]*?\*\//g, "")
+  // Single-line // comments (only full-line, not inline URLs etc.)
+  result = result.replace(/^\s*\/\/[^\n]*$/gm, "")
+  // Python/Ruby # comments (full line only)
+  result = result.replace(/^\s*#[^\n!]*$/gm, "")
+  return result
+}
+
+// ── Shared ──────────────────────────────────────────────────────────────────
+
+/** Collapse 3+ consecutive blank lines into 2. */
+function collapseBlankLines(text: string): string {
+  return text.replace(/\n{3,}/g, "\n\n")
+}
+
+// ── Public API ──────────────────────────────────────────────────────────────
+
+/**
+ * Clean file content according to the supplied config.
+ * @param content  Raw file content
+ * @param fileType 'docs' | 'code' | 'config'
+ * @param config   Cleaning options
+ */
+export function cleanContent(
+  content: string,
+  fileType: "docs" | "code" | "config",
+  config: CleaningConfig = DEFAULT_CLEANING_CONFIG,
+): string {
+  let result = content
+
+  if (fileType === "docs") {
+    if (config.remove_frontmatter_metadata) {
+      result = stripFrontmatter(result)
+    }
+    if (config.remove_toc) {
+      result = stripToc(result)
+      result = stripHtmlTocMarkers(result)
+    }
+    result = stripBreadcrumbs(result)
+  }
+
+  if (fileType === "code") {
+    result = stripAutoGenMarkers(result)
+    if (config.remove_imports) {
+      result = stripImports(result)
+    }
+    if (config.remove_comments) {
+      result = stripComments(result)
+    }
+  }
+
+  result = collapseBlankLines(result).trim()
+  return result
+}

package/vectorizer/graph-builder.ts

@@ -0,0 +1,95 @@
+import path from "path"
+import { GraphDB, Triple } from "./graph-db"
+import { RegexAnalyzer, Relation as RegexRelation } from "./analyzers/regex-analyzer"
+import { LSPAnalyzer, Relation as LSPRelation } from "./analyzers/lsp-analyzer"
+
+export interface ChunkWithId {
+  chunk_id: string
+  content: string
+  start_line?: number
+  end_line?: number
+  heading_context?: string
+}
+
+export class GraphBuilder {
+  private lspAnalyzer: LSPAnalyzer
+  private regexAnalyzer: RegexAnalyzer
+
+  constructor(
+    private graphDB: GraphDB,
+    private projectRoot: string
+  ) {
+    this.lspAnalyzer = new LSPAnalyzer()
+    this.regexAnalyzer = new RegexAnalyzer()
+  }
+
+  assignChunkIds(filePath: string, chunks: any[]): ChunkWithId[] {
+    const withoutExt = filePath.replace(/\.[^/.]+$/, "")
+    const normalizedPath = withoutExt.replace(/[^a-zA-Z0-9]/g, "_")
+
+    return chunks.map((chunk, index) => {
+      const chunkId = `chunk_${normalizedPath}_${index}`
+      return {
+        ...chunk,
+        chunk_id: chunkId
+      } as ChunkWithId
+    })
+  }
+
+  async buildEdges(
+    filePath: string,
+    content: string,
+    chunks: ChunkWithId[],
+    fileType: "code" | "docs"
+  ): Promise<void> {
+    let relations: Array<RegexRelation | LSPRelation> = []
+
+    if (fileType === "docs") {
+      relations = this.regexAnalyzer.analyzeMarkdown(filePath, content, chunks)
+    } else if (fileType === "code") {
+      const lspAvailable = await this.lspAnalyzer.isAvailable(filePath)
+      
+      if (lspAvailable) {
+        try {
+          relations = await this.lspAnalyzer.analyzeFile(filePath, chunks)
+        } catch (error) {
+          relations = this.regexAnalyzer.analyzeCode(filePath, content, chunks)
+        }
+      } else {
+        relations = this.regexAnalyzer.analyzeCode(filePath, content, chunks)
+      }
+    }
+
+    const triples: Triple[] = relations.map(rel => ({
+      subject: rel.from,
+      predicate: rel.predicate,
+      object: rel.to,
+      weight: rel.weight,
+      source: rel.source,
+      file: filePath,
+      line: rel.line
+    }))
+
+    await this.graphDB.putEdges(triples)
+  }
+
+  resolveChunkId(filePath: string, line: number): string | null {
+    const withoutExt = filePath.replace(/\.[^/.]+$/, "")
+    const normalizedPath = withoutExt.replace(/[^a-zA-Z0-9]/g, "_")
+    return `chunk_${normalizedPath}_0`
+  }
+
+  async getRelatedChunks(chunkId: string): Promise<Array<{ chunk_id: string; predicate: string; weight: number; direction: "outgoing" | "incoming" }>> {
+    const [outgoing, incoming] = await Promise.all([
+      this.graphDB.getOutgoing(chunkId),
+      this.graphDB.getIncoming(chunkId)
+    ])
+
+    const result = [
+      ...outgoing.map(t => ({ chunk_id: t.object, predicate: t.predicate, weight: t.weight, direction: "outgoing" as const })),
+      ...incoming.map(t => ({ chunk_id: t.subject, predicate: t.predicate, weight: t.weight, direction: "incoming" as const }))
+    ]
+
+    return result
+  }
+}

package/vectorizer/graph-db.ts

@@ -0,0 +1,97 @@
+import levelgraph from "levelgraph"
+import { Level } from "level"
+
+export interface Triple {
+  subject: string
+  predicate: string
+  object: string
+  weight: number
+  source: string
+  file: string
+  line?: number
+}
+
+export class GraphDB {
+  private db: any
+  private initialized: boolean = false
+
+  constructor(private dbPath: string) {}
+
+  async init(): Promise<this> {
+    const levelDb = new Level(this.dbPath)
+    this.db = levelgraph(levelDb)
+    this.initialized = true
+    return this
+  }
+
+  async putEdges(triples: Triple[]): Promise<void> {
+    if (!this.initialized) {
+      throw new Error("GraphDB not initialized. Call init() first.")
+    }
+    await new Promise<void>((resolve, reject) => {
+      this.db.put(triples, (err: Error | undefined) => {
+        if (err) reject(err)
+        else resolve()
+      })
+    })
+  }
+
+  async getOutgoing(chunkId: string): Promise<Triple[]> {
+    if (!this.initialized) {
+      throw new Error("GraphDB not initialized. Call init() first.")
+    }
+    return new Promise<Triple[]>((resolve, reject) => {
+      this.db.get({ subject: chunkId }, (err: Error | undefined, triples: Triple[]) => {
+        if (err) reject(err)
+        else resolve(triples || [])
+      })
+    })
+  }
+
+  async getIncoming(chunkId: string): Promise<Triple[]> {
+    if (!this.initialized) {
+      throw new Error("GraphDB not initialized. Call init() first.")
+    }
+    return new Promise<Triple[]>((resolve, reject) => {
+      this.db.get({ object: chunkId }, (err: Error | undefined, triples: Triple[]) => {
+        if (err) reject(err)
+        else resolve(triples || [])
+      })
+    })
+  }
+
+  async deleteByFile(filePath: string): Promise<void> {
+    if (!this.initialized) {
+      throw new Error("GraphDB not initialized. Call init() first.")
+    }
+    const allTriples = await new Promise<Triple[]>((resolve, reject) => {
+      this.db.get({}, (err: Error | undefined, triples: Triple[]) => {
+        if (err) reject(err)
+        else resolve(triples || [])
+      })
+    })
+
+    const toDelete = allTriples.filter(t => t.file === filePath)
+
+    for (const t of toDelete) {
+      await new Promise<void>((resolve, reject) => {
+        this.db.del(t, (err: Error | undefined) => {
+          if (err) reject(err)
+          else resolve()
+        })
+      })
+    }
+  }
+
+  async close(): Promise<void> {
+    if (this.initialized && this.db) {
+      await new Promise<void>((resolve, reject) => {
+        this.db.close((err: Error | undefined) => {
+          if (err) reject(err)
+          else resolve()
+        })
+      })
+      this.initialized = false
+    }
+  }
+}

package/vectorizer/hybrid-search.ts

@@ -0,0 +1,97 @@
+/**
+ * Hybrid Search — merges vector similarity and BM25 keyword scores.
+ *
+ * Uses Reciprocal Rank Fusion (RRF) or weighted linear combination
+ * to merge results from two search backends.
+ */
+
+// ── Types ───────────────────────────────────────────────────────────────────
+
+export interface HybridSearchConfig {
+  enabled: boolean
+  bm25_weight: number    // 0.0–1.0, vector_weight = 1 - bm25_weight
+}
+
+export const DEFAULT_HYBRID_CONFIG: HybridSearchConfig = {
+  enabled: false,
+  bm25_weight: 0.3,
+}
+
+export interface ScoredResult {
+  id: number              // index into the results array
+  vectorScore: number     // 0–1 (1 = best)
+  bm25Score: number       // raw BM25 score (unnormalized)
+  combinedScore: number
+}
+
+// ── Merge logic ─────────────────────────────────────────────────────────────
+
+/**
+ * Normalize BM25 scores to 0–1 range using min-max scaling.
+ */
+function normalizeBM25Scores(scores: Map<number, number>): Map<number, number> {
+  if (scores.size === 0) return scores
+
+  let min = Infinity
+  let max = -Infinity
+  for (const s of scores.values()) {
+    if (s < min) min = s
+    if (s > max) max = s
+  }
+
+  const range = max - min
+  if (range === 0) {
+    // All same score → normalize to 0.5
+    const result = new Map<number, number>()
+    for (const [id] of scores) result.set(id, 0.5)
+    return result
+  }
+
+  const result = new Map<number, number>()
+  for (const [id, score] of scores) {
+    result.set(id, (score - min) / range)
+  }
+  return result
+}
+
+/**
+ * Merge vector and BM25 results using weighted linear combination.
+ *
+ * @param vectorResults Map of chunkIndex → vectorScore (0–1, higher = better)
+ * @param bm25Results   Map of chunkIndex → raw BM25 score
+ * @param config        Hybrid search config (weights)
+ * @param limit         Max results to return
+ */
+export function mergeResults(
+  vectorResults: Map<number, number>,
+  bm25Results: Map<number, number>,
+  config: HybridSearchConfig = DEFAULT_HYBRID_CONFIG,
+  limit: number = 10,
+): ScoredResult[] {
+  const vectorWeight = 1 - config.bm25_weight
+  const bm25Weight = config.bm25_weight
+
+  const normalizedBM25 = normalizeBM25Scores(bm25Results)
+
+  // Collect all unique IDs
+  const allIds = new Set<number>()
+  for (const id of vectorResults.keys()) allIds.add(id)
+  for (const id of normalizedBM25.keys()) allIds.add(id)
+
+  const results: ScoredResult[] = []
+
+  for (const id of allIds) {
+    const vs = vectorResults.get(id) ?? 0
+    const bs = normalizedBM25.get(id) ?? 0
+
+    results.push({
+      id,
+      vectorScore: vs,
+      bm25Score: bm25Results.get(id) ?? 0,
+      combinedScore: vectorWeight * vs + bm25Weight * bs,
+    })
+  }
+
+  results.sort((a, b) => b.combinedScore - a.combinedScore)
+  return results.slice(0, limit)
+}