codeseeker 1.11.2 → 2.0.0

package/README.md

@@ -1,83 +1,129 @@
 # CodeSeeker
 
-**Graph-powered code intelligence for Claude Code.** CodeSeeker builds a knowledge graph of your codebase—not just embeddings—so Claude understands how your code actually connects.
+**Four-layer hybrid search and knowledge graph for AI coding assistants.**  
+BM25 + vector embeddings + RAPTOR directory summaries + graph expansion — fused into a single MCP tool that gives Claude, Copilot, and Cursor a real understanding of your codebase.
 
 [![npm version](https://img.shields.io/npm/v/codeseeker.svg)](https://www.npmjs.com/package/codeseeker)
 [![License: MIT](https://img.shields.io/badge/License-MIT-green.svg)](LICENSE)
 [![TypeScript](https://img.shields.io/badge/TypeScript-100%25-blue.svg)](https://www.typescriptlang.org/)
 
-> **What is CodeSeeker?** An MCP server that gives AI assistants semantic code search and knowledge graph traversal. Works with **Claude Code**, **GitHub Copilot**, **Cursor**, and **Claude Desktop**.
+Works with **Claude Code**, **GitHub Copilot** (VS Code 1.99+), **Cursor**, **Windsurf**, and **Claude Desktop**.  
+Zero configuration — indexes on first use, stays in sync automatically.
 
-> **⚠️ NOT A VS CODE EXTENSION:** CodeSeeker is installed via `npm`, not the VS Code marketplace. It's an MCP server that enhances AI assistants, not a standalone extension.
+## The Problem
 
-## Installation
+AI assistants are powerful editors, but they navigate code like a tourist:
+- **Grep finds text** — not meaning. `"find authentication logic"` returns every file containing the word "auth"
+- **File reads are isolated** — Claude sees a file but not its dependencies, callers, or the patterns your team established
+- **No memory of your project** — every session starts from scratch
 
-> **🚨 Important:** CodeSeeker is **NOT a VS Code extension**. It's an **MCP server** (Model Context Protocol) that works WITH AI assistants like Claude Code and GitHub Copilot. Don't look for it in the VS Code marketplace—install via the methods below.
+CodeSeeker fixes this. It indexes your codebase once and gives AI assistants a queryable knowledge graph they can use on every turn.
 
-### ⚡ One-Line Install (Easiest)
+## How It Works
 
-Copy/paste ONE command - auto-detects your system and configures everything:
+A 4-stage pipeline runs on every query:
 
-**macOS/Linux:**
-```bash
-curl -fsSL https://raw.githubusercontent.com/jghiringhelli/codeseeker/master/scripts/install.sh | sh
 ```
-
-**Windows (PowerShell):**
-```powershell
-irm https://raw.githubusercontent.com/jghiringhelli/codeseeker/master/scripts/install.ps1 | iex
+Query: "find JWT refresh token logic"
+        │
+        ▼  Stage 1 — Hybrid retrieval
+   ┌─────────────────────────────────────────────────────┐
+   │ BM25 (exact symbols, camelCase tokenized)           │
+   │   +                                                 │
+   │ Vector search (384-dim Xenova embeddings)           │
+   │   ↓                                                 │
+   │ Reciprocal Rank Fusion: score = Σ 1/(60 + rank_i)  │
+   │ Top-30 results, including RAPTOR directory nodes    │
+   └─────────────────────────────────────────────────────┘
+        │
+        ▼  Stage 2 — RAPTOR cascade (conditional)
+   ┌─────────────────────────────────────────────────────┐
+   │ IF best directory-summary score ≥ 0.5:              │
+   │   → narrow results to that directory automatically  │
+   │ ELSE: all 30 results pass through unchanged         │
+   │ Effect: "what does auth/ do?" scopes to auth/       │
+   │         "jwt.ts decode function" bypasses this      │
+   └─────────────────────────────────────────────────────┘
+        │
+        ▼  Stage 3 — Scoring and deduplication
+   ┌─────────────────────────────────────────────────────┐
+   │ Dedup: keep highest-score chunk per file            │
+   │ Source files:  +0.10  (definition sites matter)     │
+   │ Test files:    −0.15  (prevent test dominance)      │
+   │ Symbol boost:  +0.20  (query token in filename)     │
+   │ Multi-chunk:   up to +0.30  (file has many hits)    │
+   └─────────────────────────────────────────────────────┘
+        │
+        ▼  Stage 4 — Graph expansion
+   ┌─────────────────────────────────────────────────────┐
+   │ Top-10 results → follow IMPORTS/CALLS/EXTENDS edges │
+   │ Structural neighbors scored at source × 0.7        │
+   │ Avg graph connectivity: 20.8 edges/node             │
+   └─────────────────────────────────────────────────────┘
+        │
+        ▼
+   auth/jwt.ts (0.94), auth/refresh.ts (0.89), ...
 ```
 
-Restart your IDE and you're done!
+The knowledge graph is built from AST-parsed imports at index time. It's what powers `analyze dependencies`, dead-code detection, and graph expansion in every search.
 
-### 📦 Package Managers (Advanced)
+## What Makes It Different
 
-**Linux (Snap) - All Distributions:**
-```bash
-sudo snap install codeseeker
-codeseeker install --vscode      # or --cursor, --windsurf
-```
-> ⚠️ **Snap limitation:** Due to strict confinement, the snap can only access projects in your home directory (`~/`). For projects outside `~/`, use npm or Homebrew instead.
+| Approach | Strengths | Limitations |
+|----------|-----------|-------------|
+| **Grep / ripgrep** | Fast, universal | No semantic understanding |
+| **Vector search only** | Finds similar code | Misses structural relationships |
+| **Serena** | Precise LSP symbol navigation, 30+ languages | No semantic search, no cross-file reasoning |
+| **Codanna** | Fast symbol lookup, good call graphs | Semantic search needs JSDoc — undocumented code gets no embeddings; no BM25, no RAPTOR, Windows experimental |
+| **CodeSeeker** | BM25 + embedding fusion + RAPTOR + graph + coding standards + multi-language AST | Requires initial indexing (30s–5min) |
 
-**macOS/Linux (Homebrew):**
-```bash
-brew install jghiringhelli/codeseeker/codeseeker
-codeseeker install --vscode      # or --cursor, --windsurf
-```
+**What LSP tools can't do:**
+- *"Find code that handles errors like this"* → semantic pattern search
+- *"What validation approach does this project use?"* → auto-detected coding standards
+- *"Show me everything related to authentication"* → graph traversal across indirect dependencies
 
-**Windows (Chocolatey):**
-```powershell
-choco install codeseeker
-codeseeker install --vscode      # or --cursor, --windsurf
-```
+**What vector-only search misses:**
+- Direct import/export chains
+- Class inheritance hierarchies
+- Which files actually depend on which
 
-**Cross-platform (npm):**
-```bash
-npm install -g codeseeker
-codeseeker install --vscode      # or --cursor, --windsurf
+## Installation
+
+### Recommended: npx (no install needed)
+
+The standard way to configure any MCP server — no global install required:
+
+```json
+{
+  "mcpServers": {
+    "codeseeker": {
+      "command": "npx",
+      "args": ["-y", "codeseeker", "serve", "--mcp"]
+    }
+  }
+}
 ```
 
-### 🚀 No Install Required (npx)
+Add this to your MCP config file ([see below](#advanced-installation-options) for per-client locations) and restart your editor.
+
+### npm global install
 
-Run without installing:
 ```bash
-npx codeseeker init
-npx codeseeker -c "how does authentication work?"
+npm install -g codeseeker
+codeseeker install --vscode      # or --cursor, --windsurf
 ```
 
 ### 🔌 Claude Code Plugin
 
-If you use Claude Code CLI, you can install as a plugin:
+For Claude Code CLI users — adds auto-sync hooks and slash commands:
 
 ```bash
 /plugin install codeseeker@github:jghiringhelli/codeseeker#plugin
 ```
 
-This gives you auto-sync hooks and slash commands (`/codeseeker:init`, `/codeseeker:reindex`).
-
-### ☁️ Devcontainer / GitHub Codespaces
+Slash commands: `/codeseeker:init`, `/codeseeker:reindex`
 
-CodeSeeker auto-installs in devcontainers! Just add `.devcontainer/devcontainer.json`:
+### ☁️ Devcontainers / GitHub Codespaces
 
 ```json
 {
@@ -87,121 +133,37 @@ CodeSeeker auto-installs in devcontainers! Just add `.devcontainer/devcontainer.
 }
 ```
 
-Or use our pre-configured devcontainer (already included in this repo).
-
-### ✅ Verify Installation
+### ✅ Verify
 
 Ask your AI assistant: *"What CodeSeeker tools do you have?"*
 
-You should see: `search`, `analyze`, `index` — CodeSeeker's three unified tools.
-
----
-
-## The Problem
-
-Claude Code is powerful, but it navigates your codebase like a tourist with a phrasebook:
-- **Grep searches** find text matches, not semantic meaning
-- **File reads** show code in isolation, missing the bigger picture
-- **No memory** of your project's patterns—every session starts fresh
-
-The result? Claude asks you to explain code relationships it should already know. It writes validation logic that doesn't match your existing patterns. It misses dependencies and breaks things.
-
-## How CodeSeeker Fixes This
-
-CodeSeeker builds a **knowledge graph** of your codebase:
-
-```
-┌─────────────┐     imports      ┌─────────────┐
-│  auth.ts    │ ───────────────▶ │  user.ts    │
-└─────────────┘                  └─────────────┘
-       │                                │
-       │ calls                          │ extends
-       ▼                                ▼
-┌─────────────┐     implements   ┌─────────────┐
-│ session.ts  │ ◀─────────────── │ BaseUser.ts │
-└─────────────┘                  └─────────────┘
-```
-
-When you ask "add password reset to authentication", Claude doesn't just find files containing "auth"—it traverses the graph to find:
-- What `auth.ts` imports and exports
-- Which services call authentication functions
-- What patterns exist in related code
-- How your project handles similar flows
-
-This is **Graph RAG** (Retrieval-Augmented Generation), not just vector search.
+You should see: `search`, `analyze`, `index` — CodeSeeker's three tools.
 
 ## Advanced Installation Options
 
 <details>
-<summary><b>📋 Manual MCP Configuration</b> (if auto-install doesn't work)</summary>
-
-### VS Code (Claude Code & GitHub Copilot)
+<summary><b>📋 MCP Configuration by client</b></summary>
 
-Add to `.vscode/mcp.json` in your project:
+The MCP config JSON is the same for all clients — only the file location differs:
 
-```json
-{
-  "mcpServers": {
-    "codeseeker": {
-      "command": "npx",
-      "args": ["-y", "codeseeker", "serve", "--mcp"],
-      "env": {
-        "CODESEEKER_STORAGE_MODE": "embedded"
-      }
-    }
-  }
-}
-```
-
-### Cursor
-
-Add to `.cursor/mcp.json` in your project:
-
-```json
-{
-  "mcpServers": {
-    "codeseeker": {
-      "command": "npx",
-      "args": ["-y", "codeseeker", "serve", "--mcp"],
-      "env": {
-        "CODESEEKER_STORAGE_MODE": "embedded"
-      }
-    }
-  }
-}
-```
-
-### Claude Desktop
-
-Add to your `claude_desktop_config.json`:
-
-**macOS**: `~/Library/Application Support/Claude/claude_desktop_config.json`
-**Windows**: `%APPDATA%\Claude\claude_desktop_config.json`
+| Client | Config file |
+|--------|------------|
+| **VS Code** (Claude Code / Copilot) | `.vscode/mcp.json` in your project, or `~/.vscode/mcp.json` globally |
+| **Cursor** | `.cursor/mcp.json` in your project |
+| **Claude Desktop** | `~/Library/Application Support/Claude/claude_desktop_config.json` (macOS) or `%APPDATA%\Claude\claude_desktop_config.json` (Windows) |
+| **Windsurf** | `.windsurf/mcp.json` in your project |
 
 ```json
 {
   "mcpServers": {
     "codeseeker": {
       "command": "npx",
-      "args": ["-y", "codeseeker", "serve", "--mcp"],
-      "env": {
-        "CODESEEKER_STORAGE_MODE": "embedded"
-      }
+      "args": ["-y", "codeseeker", "serve", "--mcp"]
     }
   }
 }
 ```
 
-### Global vs Project-Level Configuration
-
-```bash
-# Apply to all projects (user-level)
-codeseeker install --vscode --global
-
-# Apply to current project only
-codeseeker install --vscode
-```
-
 </details>
 
 <details>
@@ -262,38 +224,70 @@ User: "Find the authentication logic"
 
 First search on a new project takes 30 seconds to several minutes (depending on size). Subsequent searches are instant.
 
-## What Makes It Different
+---
 
-| Approach | How It Works | Strengths | Limitations |
-|----------|--------------|-----------|-------------|
-| **Grep/ripgrep** | Text pattern matching | Fast, universal | No semantic understanding |
-| **Vector search only** | Embedding similarity | Finds similar code | Misses structural relationships |
-| **LSP-based tools** | Language server protocol | Precise symbol definitions | No semantic search, no cross-file reasoning |
-| **CodeSeeker** | Knowledge graph + hierarchical hybrid search | Semantic + structure + directory context + patterns | Requires initial indexing (30s-5min) |
+## Search Quality Research
 
-### CodeSeeker's Unique Capabilities
+<details>
+<summary><b>📊 Component ablation study (v2.0.0)</b> — measured impact of each retrieval layer</summary>
 
-**Hierarchical search (RAPTOR):**
-CodeSeeker generates *directory summary nodes* by mean-pooling the embeddings of all files in each folder, plus a *project root node* for the whole codebase. These live in the same index as regular file chunks:
-- *Concrete queries* ("find JWT refresh logic") surface precise file chunks as usual
-- *Abstract queries* ("what does the auth package do?") naturally score higher against directory summaries → instant package-level answers without enumerating 20 files
-- *On sync*, a structural hash + cosine drift check skips regeneration for most edits — no extra cost for routine code changes
+### Setup
 
-**What LSP tools can't do:**
-- *"Find code that handles errors like this"* → Semantic search finds similar patterns
-- *"What validation approach does this project use?"* → Auto-detected coding standards
-- *"Show me everything related to authentication"* → Graph traversal across indirect dependencies
+18 hand-labelled queries across two real-world codebases:
 
-**What vector-only search misses:**
-- Direct import/export relationships
-- Class inheritance chains
-- Function call graphs
-- Which files actually depend on which
+| Corpus | Language | Files | Queries | Query types |
+|--------|----------|-------|---------|-------------|
+| [Conclave](https://github.com/jghiringhelli/conclave) | TypeScript (pnpm monorepo) | 201 | 10 | Symbol lookup, cross-file chains, out-of-scope |
+| [ImperialCommander2](https://github.com/jonwill8/ImperialCommander2) | C# / Unity | 199 | 8 | Class lookup, controller wiring, file I/O |
+
+Each query has one or more `mustFind` targets (exact file basenames) and optional `mustNotFind` targets (scope leak check). Queries were run on a real index built from source — real Xenova embeddings, real graph, real RAPTOR L2 nodes — to reflect production conditions.
+
+Metrics: **MRR** (Mean Reciprocal Rank), **P@1** (Precision at 1), **R@5** (Recall at 5), **F1@3**.
+
+### Ablation results
+
+| Configuration | MRR | P@1 | P@3 | R@5 | F1@3 | Notes |
+|--------------|-----|-----|-----|-----|------|-------|
+| **Hybrid baseline** (BM25 + embed + RAPTOR, no graph) | **75.2%** | 61.1% | 29.6% | 91.7% | 44.4% | Production default |
+| + graph 1-hop | 74.9% | 61.1% | 29.6% | 91.7% | 44.4% | ±0% ranking, adds structural neighbors |
+| + graph 2-hop | 74.9% | 61.1% | 29.6% | 91.7% | 44.4% | Scope leaks on unrelated queries |
+| No RAPTOR (graph 1-hop) | 74.9% | 61.1% | 29.6% | 91.7% | 44.4% | RAPTOR contributes +0.3% |
+
+### What each layer actually does
+
+**BM25 + embedding fusion (RRF)**  
+The workhorse. Handles ~94% of ranking quality on its own. BM25 catches exact symbol names and camelCase tokens; vector embeddings catch semantic similarity when names differ. Fused with Reciprocal Rank Fusion to combine both signals without manual weight tuning.
+
+**RAPTOR (hierarchical directory summaries)**  
+Generates per-directory embedding nodes by mean-pooling all file embeddings in a folder. Acts as a post-filter: when a directory summary scores ≥ 0.5 against the query, results are narrowed to that directory's files. Measured contribution: **+0.3% MRR** on symbol queries. Fires conservatively — only when the directory is an obvious match. Its real value is on _abstract queries_ ("what does the payments module do?") which don't appear in this benchmark; for those queries it prevents broad scattering across the entire codebase.
 
-CodeSeeker combines all three: **graph traversal** for structure, **vector search** for meaning, **text search** for precision—fused with Reciprocal Rank Fusion (RRF) for optimal results.
+**Knowledge graph (import/dependency edges)**  
+Average connectivity: 20.8 file→file edges per node across both TS and C# codebases. Measured ranking impact: **±0% MRR** for 1-hop expansion. The graph doesn't move MRR because the semantic layer already finds the right files — the graph's neighbors are usually already in the top-15. Its value is structural: the `analyze dependencies` action and explicit `graph` search type give Claude traversable import chains, inheritance hierarchies, and dependency paths that embeddings alone cannot provide.
 
-**Search quality guarantee:**
-Every release is gated by a precision/recall benchmark suite that runs 104 tests across hand-curated TypeScript, Python, and Go fixtures (JWT middleware, generic repositories, async ORMs, Pydantic schemas, goroutine workers, and more). FTS, hybrid, and graph modes must all achieve R@5 = 1.0 and MRR = 1.0 for language-specific queries; a regression of more than 0.15 on any (query × mode) cell blocks the release automatically.
+**Type boost / penalty scoring**  
+Source files get +0.10 score boost; test files get −0.15 penalty; lock files and docs get −0.05 penalty. Without this, `integration.test.ts` would rank above `dag-engine.ts` for exact symbol queries because test files import and exercise every symbol in the source. The penalty corrects this without eliminating test files from results.
+
+**Monorepo directory exclusion fix**  
+The single highest-impact change in v1.12.0: removing `packages/` from the default exclusion list. For pnpm/yarn/lerna monorepos where all source lives under `packages/`, this exclusion was silently dropping all source files. Effect: **10% → 72% MRR** on the Conclave monorepo benchmark.
+
+### Known limitations
+
+| Query | Target | Issue | Root cause |
+|-------|--------|-------|-----------|
+| `cv-prompts` | `orchestrator.ts` | rank 97+ even with 2-hop graph | `prompt-builder.test.ts` outscores `prompt-builder.ts` semantically; source file never enters top-10, so we can't graph-walk from it to `orchestrator.ts`. Test-file dominance on cross-file queries. |
+| `cv-exec-mode` | `types.ts` | rank 11–12 | `types.ts` is a pure type-export file; low keyword density. Found within R@5 (rank ≤ 15). |
+
+### Benchmark script
+
+Reproduce with:
+```bash
+npm run build
+node scripts/real-bench.js
+```
+
+Requires `C:\workspace\claude\conclave` and `C:\workspace\ImperialCommander2` to be present locally (or update paths in `scripts/real-bench.js`).
+
+</details>
 
 ## Auto-Detected Coding Standards
 
@@ -474,14 +468,9 @@ All data stored locally in `.codeseeker/`. No external services required.
 
 For large teams (100K+ files, shared indexes), server mode supports PostgreSQL + Neo4j. See [Storage Documentation](docs/technical/storage.md).
 
-## Troubleshooting
+For the complete technical internals — exact scoring formulas, MCP tool schema, graph edge types, RAPTOR threshold logic, pipeline stages, analysis confidence tiers — see the **[Technical Architecture Manual](docs/technical/architecture.md)**.
 
-### "I can't find CodeSeeker in the VS Code marketplace"
-
-**CodeSeeker is NOT a VS Code extension.** It's an MCP server that works WITH AI assistants.
-
-✅ **Correct:** Install via npm: `npm install -g codeseeker`
-❌ **Wrong:** Looking for it in VS Code Extensions marketplace
+## Troubleshooting
 
 ### MCP server not connecting
 
@@ -513,16 +502,16 @@ Open an issue: [GitHub Issues](https://github.com/jghiringhelli/codeseeker/issue
 
 ## Supported Platforms
 
-| Platform | MCP Support | Install Command |
-|----------|-------------|-----------------|
-| **Claude Code** (VS Code) | Yes | `codeseeker install --vscode` or plugin |
-| **GitHub Copilot** (VS Code) | Yes (VS Code 1.99+) | `codeseeker install --vscode` |
-| **Cursor** | Yes | `codeseeker install --cursor` |
-| **Claude Desktop** | Yes | Manual config |
-| **Windsurf** | Yes | `codeseeker install --windsurf` |
-| **Visual Studio** | Yes | `codeseeker install --vs` |
+| Client | MCP Support | Config |
+|--------|-------------|--------|
+| **Claude Code** (VS Code) | ✅ | `.vscode/mcp.json` or plugin |
+| **GitHub Copilot** (VS Code 1.99+) | ✅ | `.vscode/mcp.json` |
+| **Cursor** | ✅ | `.cursor/mcp.json` |
+| **Windsurf** | ✅ | `.windsurf/mcp.json` |
+| **Claude Desktop** | ✅ | `claude_desktop_config.json` |
+| **Visual Studio** | ✅ | `codeseeker install --vs` |
 
-> **Note:** Claude Code and GitHub Copilot both run in VS Code and share the same MCP configuration (`.vscode/mcp.json`). The flags `--vscode`, `--claude-code`, and `--copilot` are interchangeable.
+> Claude Code and GitHub Copilot share the same `.vscode/mcp.json` — configure once, works for both.
 
 ## Support
 

package/dist/cli/commands/services/semantic-search-orchestrator.d.ts

@@ -44,6 +44,8 @@ export declare class SemanticSearchOrchestrator {
     private vectorStore?;
     private projectStore?;
     private graphStore?;
+    /** Current query — set at the start of performSemanticSearch, used for symbol-name boosting */
+    private currentQuery;
     constructor();
     /**
      * Initialize storage - checks if we should use embedded or server mode
@@ -64,12 +66,41 @@ export declare class SemanticSearchOrchestrator {
      * Returns empty array if storage unavailable or no results - Claude handles file discovery natively
      */
     performSemanticSearch(query: string, projectPath: string, searchType?: 'hybrid' | 'vector' | 'fts' | 'graph'): Promise<SemanticResult[]>;
+    /** Minimum L2 RAPTOR node score to trust its directory hint */
+    private l2Threshold;
+    /** Minimum number of results cascade must produce to skip fallback */
+    private cascadeMinResults;
+    /** Minimum top-result score cascade must produce to skip fallback */
+    private cascadeTopScore;
+    /** Override RAPTOR cascade thresholds — useful for tuning experiments. */
+    setRaptorConfig(config: {
+        l2Threshold?: number;
+        cascadeMinResults?: number;
+        cascadeTopScore?: number;
+    }): void;
     /**
-     * Perform hybrid search using the storage interface abstraction
-     * Works for both embedded (SQLite + MiniSearch) and server (PostgreSQL + pgvector) modes
-     * The IVectorStore implementation handles the specific search logic internally
+     * Depth of graph neighbor expansion after hybrid search.
+     * 0 = disabled, 1 = 1-hop (default), 2 = 2-hop (cross-file chains)
+     */
+    private graphExpansionDepth;
+    /** Configure graph expansion depth. 0 disables expansion entirely. */
+    setGraphExpansionDepth(depth: number): void;
+    /**
+     * Perform hybrid search using the storage interface abstraction.
+     * Works for both embedded (SQLite + MiniSearch) and server (PostgreSQL + pgvector) modes.
+     *
+     * RAPTOR Cascade (post-processing):
+     *  1. Run wide searchHybrid (one call, always happens)
+     *  2. Extract RAPTOR L2 nodes from raw results
+     *  3. If a high-confidence L2 node exists, post-filter real files to its dir(s)
+     *  4. If the filtered set is thin or low-confidence, fall back to full wide results
      */
     private performHybridSearchViaInterface;
+    /**
+     * Apply RAPTOR cascade post-filter.
+     * Returns filtered SemanticResult[] when cascade is confident, null when falling back.
+     */
+    private applyCascadeFilter;
     /**
      * Perform vector-only semantic search (pure embedding similarity, no BM25/path matching)
      */
@@ -84,9 +115,10 @@ export declare class SemanticSearchOrchestrator {
      */
     private processRawResults;
     /**
-     * Graph RAG: expand hybrid search results by following 1-hop code relationship edges.
+     * Graph RAG: expand hybrid search results by following code relationship edges.
      * For each of the top-5 result files, lookup its graph node and collect neighbours
      * (files connected via imports/calls/extends). Appends new files at a discounted score.
+     * @param depth  1 = 1-hop, 2 = 2-hop (follows neighbors of neighbors for cross-file chains)
      */
     private expandWithGraphNeighbors;
     /**

package/dist/cli/commands/services/semantic-search-orchestrator.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"semantic-search-orchestrator.d.ts","sourceRoot":"","sources":["../../../../src/cli/commands/services/semantic-search-orchestrator.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AASH,MAAM,WAAW,cAAc;IAC7B,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,UAAU,EAAE,MAAM,CAAC;IACnB,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,8DAA8D;IAC9D,KAAK,CAAC,EAAE;QACN,WAAW,EAAE,MAAM,CAAC;QACpB,SAAS,EAAE,MAAM,CAAC;QAClB,SAAS,EAAE,OAAO,CAAC;QACnB,WAAW,EAAE,MAAM,CAAC;KACrB,CAAC;CACH;AAED,qBAAa,0BAA0B;IACrC,OAAO,CAAC,MAAM,CAAwB;IACtC,OAAO,CAAC,SAAS,CAAC,CAAS;IAC3B,OAAO,CAAC,kBAAkB,CAA4B;IACtD,OAAO,CAAC,cAAc,CAA+B;IACrD,OAAO,CAAC,WAAW,CAAkB;IACrC,OAAO,CAAC,WAAW,CAAC,CAAe;IACnC,OAAO,CAAC,YAAY,CAAC,CAAgB;IACrC,OAAO,CAAC,UAAU,CAAC,CAAc;;IAMjC;;OAEG;YACW,WAAW;IAgBzB;;OAEG;IACH,YAAY,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI;IAIrC;;OAEG;YACW,gBAAgB;IA0B9B;;;;;OAKG;IACG,qBAAqB,CAAC,KAAK,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,EAAE,UAAU,GAAE,QAAQ,GAAG,QAAQ,GAAG,KAAK,GAAG,OAAkB,GAAG,OAAO,CAAC,cAAc,EAAE,CAAC;IA4CxJ;;;;OAIG;YACW,+BAA+B;IA4B7C;;OAEG;YACW,uBAAuB;IAoBrC;;OAEG;YACW,qBAAqB;IAYnC;;;OAGG;IACH,OAAO,CAAC,iBAAiB;IA+DzB;;;;OAIG;YACW,wBAAwB;IAsEtC;;OAEG;IACH,OAAO,CAAC,WAAW;IAKnB;;OAEG;IACH,OAAO,CAAC,aAAa;IA0BrB;;OAEG;IACH,OAAO,CAAC,iBAAiB;CAiC1B"}
+{"version":3,"file":"semantic-search-orchestrator.d.ts","sourceRoot":"","sources":["../../../../src/cli/commands/services/semantic-search-orchestrator.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AASH,MAAM,WAAW,cAAc;IAC7B,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,UAAU,EAAE,MAAM,CAAC;IACnB,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,8DAA8D;IAC9D,KAAK,CAAC,EAAE;QACN,WAAW,EAAE,MAAM,CAAC;QACpB,SAAS,EAAE,MAAM,CAAC;QAClB,SAAS,EAAE,OAAO,CAAC;QACnB,WAAW,EAAE,MAAM,CAAC;KACrB,CAAC;CACH;AAED,qBAAa,0BAA0B;IACrC,OAAO,CAAC,MAAM,CAAwB;IACtC,OAAO,CAAC,SAAS,CAAC,CAAS;IAC3B,OAAO,CAAC,kBAAkB,CAA4B;IACtD,OAAO,CAAC,cAAc,CAA+B;IACrD,OAAO,CAAC,WAAW,CAAkB;IACrC,OAAO,CAAC,WAAW,CAAC,CAAe;IACnC,OAAO,CAAC,YAAY,CAAC,CAAgB;IACrC,OAAO,CAAC,UAAU,CAAC,CAAc;IAEjC,+FAA+F;IAC/F,OAAO,CAAC,YAAY,CAAc;;IAMlC;;OAEG;YACW,WAAW;IAgBzB;;OAEG;IACH,YAAY,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI;IAIrC;;OAEG;YACW,gBAAgB;IA0B9B;;;;;OAKG;IACG,qBAAqB,CAAC,KAAK,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,EAAE,UAAU,GAAE,QAAQ,GAAG,QAAQ,GAAG,KAAK,GAAG,OAAkB,GAAG,OAAO,CAAC,cAAc,EAAE,CAAC;IAoDxJ,+DAA+D;IAC/D,OAAO,CAAC,WAAW,CAAO;IAC1B,sEAAsE;IACtE,OAAO,CAAC,iBAAiB,CAAK;IAC9B,qEAAqE;IACrE,OAAO,CAAC,eAAe,CAAQ;IAE/B,0EAA0E;IAC1E,eAAe,CAAC,MAAM,EAAE;QAAE,WAAW,CAAC,EAAE,MAAM,CAAC;QAAC,iBAAiB,CAAC,EAAE,MAAM,CAAC;QAAC,eAAe,CAAC,EAAE,MAAM,CAAA;KAAE,GAAG,IAAI;IAO7G;;;OAGG;IACH,OAAO,CAAC,mBAAmB,CAAK;IAEhC,sEAAsE;IACtE,sBAAsB,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI;IAI3C;;;;;;;;;OASG;YACW,+BAA+B;IAkC7C;;;OAGG;IACH,OAAO,CAAC,kBAAkB;IAgE1B;;OAEG;YACW,uBAAuB;IAoBrC;;OAEG;YACW,qBAAqB;IAYnC;;;OAGG;IACH,OAAO,CAAC,iBAAiB;IAgIzB;;;;;OAKG;YACW,wBAAwB;IAyGtC;;OAEG;IACH,OAAO,CAAC,WAAW;IAKnB;;OAEG;IACH,OAAO,CAAC,aAAa;IA0BrB;;OAEG;IACH,OAAO,CAAC,iBAAiB;CAiC1B"}