src-mcp 1.0.1 → 1.0.3

package/dist/server-DL8hfycz.mjs

@@ -0,0 +1,3791 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { z } from "zod";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import ignore from "ignore";
+import { Ollama } from "ollama";
+import * as lancedb from "@lancedb/lancedb";
+import pc from "picocolors";
+import "ora";
+import * as crypto from "node:crypto";
+import { existsSync, readFileSync } from "fs";
+import { dirname, join } from "path";
+import { Language, Parser, Query } from "web-tree-sitter";
+import { fileURLToPath } from "url";
+import { watch } from "chokidar";
+import fg from "fast-glob";
+import "@langchain/textsplitters";
+
+//#region src/config/index.ts
+const config = {
+	name: "src-mcp",
+	fullName: "SRC (Structured Repo Context)",
+	version: "1.0.3",
+	description: "MCP server for codebase analysis with Treesitter (SCM queries), AST parsing, and embedding-based indexing"
+};
+const nodeEnv = process.env.NODE_ENV;
+const logLevelEnv = process.env.LOG_LEVEL;
+const ENV = {
+	isDev: nodeEnv === "development",
+	isProd: nodeEnv === "production",
+	logLevel: logLevelEnv ?? "info"
+};
+/**
+* Embedding configuration with environment variable overrides
+*/
+const EMBEDDING_CONFIG = {
+	ollamaBaseUrl: process.env.OLLAMA_BASE_URL ?? "http://localhost:11434",
+	embeddingModel: process.env.EMBEDDING_MODEL ?? "nomic-embed-text",
+	embeddingDimensions: Number(process.env.EMBEDDING_DIMENSIONS) || 768,
+	defaultChunkSize: Number(process.env.CHUNK_SIZE) || 1e3,
+	defaultChunkOverlap: Number(process.env.CHUNK_OVERLAP) || 200,
+	batchSize: Number(process.env.EMBEDDING_BATCH_SIZE) || 10
+};
+/**
+* Enrichment configuration for cross-file context
+*/
+const ENRICHMENT_CONFIG = {
+	includeCrossFileContext: process.env.ENRICHMENT_CROSS_FILE !== "false",
+	maxImportsToResolve: Number(process.env.ENRICHMENT_MAX_IMPORTS) || 10,
+	maxSymbolsPerImport: Number(process.env.ENRICHMENT_MAX_SYMBOLS_PER_IMPORT) || 5
+};
+
+//#endregion
+//#region src/features/info/index.ts
+const infoSchema = z.object({ format: z.enum(["json", "text"]).optional().default("text").describe("Output format") });
+function getServerInfo() {
+	return {
+		name: config.name,
+		fullName: config.fullName,
+		version: config.version,
+		description: config.description
+	};
+}
+function execute$4(input) {
+	const info = getServerInfo();
+	if (input.format === "json") return {
+		success: true,
+		data: info,
+		message: JSON.stringify(info, null, 2)
+	};
+	const description = info.description ?? "";
+	return {
+		success: true,
+		data: info,
+		message: `${info.fullName} (${info.name}) v${info.version}\n${description}`.trim()
+	};
+}
+const infoFeature = {
+	name: "get_server_info",
+	description: "Get SRC server version and capabilities. Use to verify the MCP server is running correctly.",
+	schema: infoSchema,
+	execute: execute$4
+};
+
+//#endregion
+//#region src/core/embeddings/client.ts
+/**
+* Ollama client for generating embeddings
+* Uses the official ollama library
+*/
+var OllamaClient = class {
+	client;
+	model;
+	constructor(config$1) {
+		this.client = new Ollama({ host: config$1.ollamaBaseUrl });
+		this.model = config$1.embeddingModel;
+	}
+	/**
+	* Generate embeddings for a single text
+	*/
+	async embed(text) {
+		const result = (await this.client.embed({
+			model: this.model,
+			input: text
+		})).embeddings[0];
+		if (!result) throw new Error("No embedding returned from Ollama");
+		return result;
+	}
+	/**
+	* Generate embeddings for multiple texts in a single request
+	*/
+	async embedBatch(texts) {
+		return (await this.client.embed({
+			model: this.model,
+			input: texts
+		})).embeddings;
+	}
+	/**
+	* Check if Ollama is reachable and the model is available
+	*/
+	async healthCheck() {
+		try {
+			if (!(await this.client.list()).models.some((m) => m.name === this.model || m.name.startsWith(`${this.model}:`))) return {
+				ok: false,
+				error: `Model "${this.model}" not found. Run: ollama pull ${this.model}`
+			};
+			return { ok: true };
+		} catch (error) {
+			return {
+				ok: false,
+				error: `Cannot connect to Ollama: ${error instanceof Error ? error.message : String(error)}`
+			};
+		}
+	}
+};
+/**
+* Create a new Ollama client with default config
+*/
+function createOllamaClient(config$1) {
+	return new OllamaClient(config$1);
+}
+
+//#endregion
+//#region src/utils/logger.ts
+const LOG_LEVELS = {
+	debug: 0,
+	info: 1,
+	warn: 2,
+	error: 3
+};
+const LEVEL_COLORS = {
+	debug: pc.dim,
+	info: pc.blue,
+	warn: pc.yellow,
+	error: pc.red
+};
+function isValidLogLevel(level) {
+	return level in LOG_LEVELS;
+}
+function shouldLog(level) {
+	const configLevel = ENV.logLevel;
+	const currentLevel = isValidLogLevel(configLevel) ? LOG_LEVELS[configLevel] : LOG_LEVELS.info;
+	return LOG_LEVELS[level] >= currentLevel;
+}
+function formatMessage(level, message) {
+	return `${pc.dim((/* @__PURE__ */ new Date()).toISOString())} ${LEVEL_COLORS[level](level.toUpperCase().padEnd(5))} ${message}`;
+}
+const logger = {
+	debug(message, ...args) {
+		if (shouldLog("debug")) console.error(formatMessage("debug", message), ...args);
+	},
+	info(message, ...args) {
+		if (shouldLog("info")) console.error(formatMessage("info", message), ...args);
+	},
+	warn(message, ...args) {
+		if (shouldLog("warn")) console.warn(formatMessage("warn", message), ...args);
+	},
+	error(message, ...args) {
+		if (shouldLog("error")) console.error(formatMessage("error", message), ...args);
+	},
+	success(message, ...args) {
+		console.error(pc.green("✓ ") + message, ...args);
+	}
+};
+
+//#endregion
+//#region src/utils/colors.ts
+/**
+* Color utilities for CLI output
+*/
+const colors = {
+	success: pc.green,
+	error: pc.red,
+	warn: pc.yellow,
+	info: pc.blue,
+	dim: pc.dim,
+	bold: pc.bold,
+	cyan: pc.cyan,
+	magenta: pc.magenta,
+	successBold: (text) => pc.bold(pc.green(text)),
+	errorBold: (text) => pc.bold(pc.red(text)),
+	infoBold: (text) => pc.bold(pc.blue(text)),
+	formatSuccess: (msg) => `${pc.green("✓")} ${msg}`,
+	formatError: (msg) => `${pc.red("✗")} ${msg}`,
+	formatInfo: (msg) => `${pc.blue("ℹ")} ${msg}`,
+	formatWarn: (msg) => `${pc.yellow("⚠")} ${msg}`,
+	formatCommand: (cmd) => pc.cyan(cmd),
+	formatValue: (val) => pc.magenta(val),
+	formatPath: (path$1) => pc.dim(path$1)
+};
+
+//#endregion
+//#region src/core/embeddings/store.ts
+/**
+* LanceDB vector store for code embeddings
+*
+* Supports:
+* - Vector similarity search (embeddings)
+* - Full-text search (BM25)
+* - Hybrid search with RRF (Reciprocal Rank Fusion)
+*/
+const TABLE_NAME = "code_chunks";
+const INDEX_DIR_NAME = ".src-index";
+/**
+* Reciprocal Rank Fusion (RRF) to combine ranked lists
+*
+* RRF score = sum(1 / (k + rank_i)) for each list
+* where k is a constant (typically 60) and rank_i is the 1-based rank in list i
+*/
+function rrfFusion(vectorResults, ftsResults, k = 60) {
+	const scores = /* @__PURE__ */ new Map();
+	vectorResults.forEach((result, index) => {
+		const rrfScore = 1 / (k + (index + 1));
+		const existing = scores.get(result.chunk.id);
+		if (existing) existing.score += rrfScore;
+		else scores.set(result.chunk.id, {
+			score: rrfScore,
+			result
+		});
+	});
+	ftsResults.forEach((result, index) => {
+		const rrfScore = 1 / (k + (index + 1));
+		const existing = scores.get(result.chunk.id);
+		if (existing) existing.score += rrfScore;
+		else scores.set(result.chunk.id, {
+			score: rrfScore,
+			result
+		});
+	});
+	return Array.from(scores.values()).sort((a, b) => b.score - a.score).map(({ score, result }) => ({
+		...result,
+		score
+	}));
+}
+/**
+* LanceDB vector store wrapper
+*/
+var VectorStore = class {
+	db = null;
+	table = null;
+	indexPath;
+	ftsIndexCreated = false;
+	constructor(directory, _config) {
+		this.indexPath = path.join(directory, INDEX_DIR_NAME);
+	}
+	/**
+	* Initialize the database connection
+	*/
+	async connect() {
+		this.db = await lancedb.connect(this.indexPath);
+		if ((await this.db.tableNames()).includes(TABLE_NAME)) this.table = await this.db.openTable(TABLE_NAME);
+	}
+	/**
+	* Close the database connection
+	*/
+	close() {
+		this.db = null;
+		this.table = null;
+	}
+	/**
+	* Check if the index exists
+	*/
+	exists() {
+		return fs.existsSync(this.indexPath);
+	}
+	/**
+	* Add embedded chunks to the store
+	*/
+	async addChunks(chunks) {
+		if (!this.db) throw new Error("Database not connected. Call connect() first.");
+		const records = chunks.map((chunk) => ({
+			id: chunk.id,
+			content: chunk.content,
+			filePath: chunk.filePath,
+			language: chunk.language,
+			startLine: chunk.startLine,
+			endLine: chunk.endLine,
+			symbolName: chunk.symbolName ?? "",
+			symbolType: chunk.symbolType ?? "",
+			vector: chunk.vector
+		}));
+		if (!this.table) this.table = await this.db.createTable(TABLE_NAME, records);
+		else await this.table.add(records);
+	}
+	/**
+	* Create FTS (Full-Text Search) index on content column
+	* This enables BM25-based text search
+	*/
+	async createFtsIndex() {
+		if (!this.table || this.ftsIndexCreated) return;
+		try {
+			await this.table.createIndex("content", { config: lancedb.Index.fts() });
+			this.ftsIndexCreated = true;
+			logger.debug("FTS index created on content column");
+		} catch (error) {
+			if (error instanceof Error && error.message.includes("already exists")) {
+				this.ftsIndexCreated = true;
+				logger.debug("FTS index already exists");
+			} else logger.warn(`Failed to create FTS index: ${error instanceof Error ? error.message : String(error)}`);
+		}
+	}
+	/**
+	* Search for similar chunks using vector similarity
+	*/
+	async search(queryVector, limit = 10) {
+		if (!this.table) return [];
+		return (await this.table.vectorSearch(queryVector).limit(limit).toArray()).map((row) => ({
+			chunk: {
+				id: row.id,
+				content: row.content,
+				filePath: row.filePath,
+				language: row.language,
+				startLine: row.startLine,
+				endLine: row.endLine,
+				symbolName: row.symbolName || void 0,
+				symbolType: row.symbolType || void 0
+			},
+			score: row._distance ?? 0
+		}));
+	}
+	/**
+	* Full-text search using BM25
+	*/
+	async searchFts(queryText, limit = 10) {
+		if (!this.table) return [];
+		await this.createFtsIndex();
+		try {
+			return (await this.table.query().nearestToText(queryText).limit(limit).toArray()).map((row, index) => ({
+				chunk: {
+					id: row.id,
+					content: row.content,
+					filePath: row.filePath,
+					language: row.language,
+					startLine: row.startLine,
+					endLine: row.endLine,
+					symbolName: row.symbolName || void 0,
+					symbolType: row.symbolType || void 0
+				},
+				score: 1 / (index + 1)
+			}));
+		} catch (error) {
+			logger.warn(`FTS search failed, falling back to empty results: ${error instanceof Error ? error.message : String(error)}`);
+			return [];
+		}
+	}
+	/**
+	* Hybrid search combining vector similarity and full-text search
+	* Uses Reciprocal Rank Fusion (RRF) to combine results
+	*/
+	async searchHybrid(queryVector, queryText, limit = 10, options = {}) {
+		const { mode = "hybrid", rrfK = 60 } = options;
+		if (!this.table) return [];
+		if (mode === "vector") return this.search(queryVector, limit);
+		if (mode === "fts") return this.searchFts(queryText, limit);
+		const [vectorResults, ftsResults] = await Promise.all([this.search(queryVector, limit * 2), this.searchFts(queryText, limit * 2)]);
+		return rrfFusion(vectorResults, ftsResults, rrfK).slice(0, limit);
+	}
+	/**
+	* Delete chunks by file path
+	*/
+	async deleteByFilePath(filePath) {
+		if (!this.table) return;
+		await this.table.delete(`"filePath" = '${filePath.replace(/'/g, "''")}'`);
+	}
+	/**
+	* Clear all data from the store
+	*/
+	async clear() {
+		if (this.db && this.table) {
+			await this.db.dropTable(TABLE_NAME);
+			this.table = null;
+		}
+	}
+	/**
+	* Get index status
+	*/
+	async getStatus(directory) {
+		const status = {
+			directory,
+			indexPath: this.indexPath,
+			exists: this.exists(),
+			totalChunks: 0,
+			totalFiles: 0,
+			languages: {}
+		};
+		if (!this.table) return status;
+		const allRows = await this.table.query().toArray();
+		status.totalChunks = allRows.length;
+		const uniqueFiles = /* @__PURE__ */ new Set();
+		const languageCounts = {};
+		for (const row of allRows) {
+			uniqueFiles.add(row.filePath);
+			const lang = row.language;
+			languageCounts[lang] = (languageCounts[lang] ?? 0) + 1;
+		}
+		status.totalFiles = uniqueFiles.size;
+		status.languages = languageCounts;
+		return status;
+	}
+	/**
+	* Get all indexed file paths
+	*/
+	async getIndexedFiles() {
+		if (!this.table) return [];
+		const rows = await this.table.query().select(["filePath"]).toArray();
+		const uniqueFiles = /* @__PURE__ */ new Set();
+		for (const row of rows) uniqueFiles.add(row.filePath);
+		return Array.from(uniqueFiles);
+	}
+};
+/**
+* Create a vector store for a directory
+*/
+function createVectorStore(directory, config$1) {
+	return new VectorStore(directory, config$1);
+}
+/**
+* Get the index path for a directory
+*/
+function getIndexPath(directory) {
+	return path.join(directory, INDEX_DIR_NAME);
+}
+
+//#endregion
+//#region src/core/utils/assets.ts
+/**
+* Centralized asset directory utilities
+*
+* Provides consistent access to the assets directory and JSON config loading
+* across all core modules.
+*/
+/**
+* Cached assets directory path
+*/
+let assetsDirCache = null;
+/**
+* Get the assets directory path
+*
+* Handles both ESM and CJS contexts by trying multiple possible paths
+* relative to the current module location.
+*/
+function getAssetsDir() {
+	if (assetsDirCache) return assetsDirCache;
+	const currentDir = typeof __dirname !== "undefined" ? __dirname : dirname(fileURLToPath(import.meta.url));
+	const possiblePaths = [
+		join(currentDir, "..", "..", "..", "assets"),
+		join(currentDir, "..", "..", "assets"),
+		join(process.cwd(), "assets")
+	];
+	for (const p of possiblePaths) if (existsSync(p)) {
+		assetsDirCache = p;
+		return p;
+	}
+	assetsDirCache = join(process.cwd(), "assets");
+	return assetsDirCache;
+}
+/**
+* Load and parse a JSON config file from the assets directory
+*
+* @param filename - Name of the JSON file in assets directory
+* @param defaultValue - Default value to return if file cannot be loaded
+* @returns Parsed JSON content or default value
+*/
+function loadJsonConfig(filename, defaultValue) {
+	const configPath = join(getAssetsDir(), filename);
+	try {
+		const content = readFileSync(configPath, "utf-8");
+		return JSON.parse(content);
+	} catch {
+		return defaultValue;
+	}
+}
+/**
+* Get the path to a file within the assets directory
+*
+* @param segments - Path segments relative to assets directory
+* @returns Full path to the asset file
+*/
+function getAssetPath(...segments) {
+	return join(getAssetsDir(), ...segments);
+}
+/**
+* Check if an asset file exists
+*
+* @param segments - Path segments relative to assets directory
+* @returns True if the file exists
+*/
+function assetExists(...segments) {
+	return existsSync(getAssetPath(...segments));
+}
+
+//#endregion
+//#region src/core/utils/cache.ts
+/**
+* Registry of cache clear functions
+*/
+const cacheRegistry = /* @__PURE__ */ new Map();
+/**
+* Register a cache clear function
+*
+* @param name - Unique name for this cache (for debugging/identification)
+* @param clearFn - Function that clears the cache
+*/
+function registerCache(name, clearFn) {
+	cacheRegistry.set(name, clearFn);
+}
+
+//#endregion
+//#region src/core/utils/tsconfig.ts
+/**
+* TSConfig utilities for reading path aliases
+*
+* Reads and parses tsconfig.json to extract path aliases
+* in a format usable by the cross-file resolution system.
+*/
+/**
+* Strip JSON comments (single-line // and multi-line)
+*/
+function stripJsonComments(json) {
+	let result = "";
+	let inString = false;
+	let inSingleLineComment = false;
+	let inMultiLineComment = false;
+	for (let i = 0; i < json.length; i++) {
+		const char = json.charAt(i);
+		const nextChar = json.charAt(i + 1);
+		if (inSingleLineComment) {
+			if (char === "\n") {
+				inSingleLineComment = false;
+				result += char;
+			}
+			continue;
+		}
+		if (inMultiLineComment) {
+			if (char === "*" && nextChar === "/") {
+				inMultiLineComment = false;
+				i++;
+			}
+			continue;
+		}
+		if (inString) {
+			result += char;
+			if (char === "\"" && json.charAt(i - 1) !== "\\") inString = false;
+			continue;
+		}
+		if (char === "\"") {
+			inString = true;
+			result += char;
+		} else if (char === "/" && nextChar === "/") {
+			inSingleLineComment = true;
+			i++;
+		} else if (char === "/" && nextChar === "*") {
+			inMultiLineComment = true;
+			i++;
+		} else result += char;
+	}
+	return result;
+}
+/**
+* Parse tsconfig.json content
+*/
+function parseTsConfig(content) {
+	try {
+		const strippedContent = stripJsonComments(content);
+		return JSON.parse(strippedContent);
+	} catch (error) {
+		logger.debug(`Failed to parse tsconfig.json: ${error instanceof Error ? error.message : String(error)}`);
+		return null;
+	}
+}
+/**
+* Convert tsconfig paths to simple path aliases format
+*
+* TSConfig format:
+*   "@core": ["src/core"]
+*   "@core/*": ["src/core/*"]
+*
+* Output format:
+*   "@core": "src/core"
+*   "@core/": "src/core/"
+*/
+function convertPaths(paths, baseUrl, projectRoot) {
+	const aliases = {};
+	for (const [pattern, targets] of Object.entries(paths)) {
+		const target = targets[0];
+		if (!target) continue;
+		if (pattern.endsWith("/*") && target.endsWith("/*")) {
+			const aliasPrefix = pattern.slice(0, -2) + "/";
+			const targetPath = target.slice(0, -2) + "/";
+			const resolvedTarget = path.join(projectRoot, baseUrl, targetPath);
+			aliases[aliasPrefix] = path.relative(projectRoot, resolvedTarget).replace(/\\/g, "/") + "/";
+		} else {
+			const resolvedTarget = path.join(projectRoot, baseUrl, target);
+			aliases[pattern] = path.relative(projectRoot, resolvedTarget).replace(/\\/g, "/");
+		}
+	}
+	return aliases;
+}
+/**
+* Read tsconfig.json and extract path aliases
+*
+* Handles:
+* - Comments in tsconfig (// and /* *\/)
+* - baseUrl relative paths
+* - Wildcard patterns (@core/* -> src/core/*)
+* - Exact patterns (@core -> src/core)
+*
+* @param projectRoot - The project root directory containing tsconfig.json
+* @returns Path aliases in simple format, or empty object if not found/invalid
+*/
+function readPathAliases(projectRoot) {
+	const tsconfigPath = path.join(projectRoot, "tsconfig.json");
+	if (!fs.existsSync(tsconfigPath)) {
+		logger.debug(`No tsconfig.json found at ${tsconfigPath}`);
+		return {};
+	}
+	try {
+		const tsconfig = parseTsConfig(fs.readFileSync(tsconfigPath, "utf-8"));
+		if (!tsconfig) return {};
+		const paths = tsconfig.compilerOptions?.paths;
+		const baseUrl = tsconfig.compilerOptions?.baseUrl ?? ".";
+		if (!paths || Object.keys(paths).length === 0) {
+			logger.debug("No paths defined in tsconfig.json");
+			return {};
+		}
+		const aliases = convertPaths(paths, baseUrl, projectRoot);
+		logger.debug(`Loaded ${String(Object.keys(aliases).length)} path aliases from tsconfig.json`);
+		return aliases;
+	} catch (error) {
+		logger.debug(`Failed to read tsconfig.json: ${error instanceof Error ? error.message : String(error)}`);
+		return {};
+	}
+}
+/**
+* Get cache key for memoization
+*/
+const pathAliasCache = /* @__PURE__ */ new Map();
+/**
+* Read path aliases with caching
+*/
+function readPathAliasesCached(projectRoot) {
+	const normalizedRoot = path.normalize(projectRoot);
+	const cached = pathAliasCache.get(normalizedRoot);
+	if (cached !== void 0) return cached;
+	const aliases = readPathAliases(projectRoot);
+	pathAliasCache.set(normalizedRoot, aliases);
+	return aliases;
+}
+
+//#endregion
+//#region src/core/parser/languages.ts
+/**
+* Language configuration and mapping for Tree-sitter parsers
+* Reads from centralized assets/languages.json
+*/
+let configCache$1 = null;
+let languagesCache = null;
+let extensionMapCache = null;
+function loadConfig() {
+	if (configCache$1) return configCache$1;
+	configCache$1 = loadJsonConfig("languages.json", { treesitter: {} });
+	return configCache$1;
+}
+function buildLanguages() {
+	if (languagesCache) return languagesCache;
+	const config$1 = loadConfig();
+	languagesCache = {};
+	for (const [name, lang] of Object.entries(config$1.treesitter)) {
+		languagesCache[name] = {
+			name,
+			wasm: lang.wasm,
+			queries: lang.queries,
+			extensions: lang.extensions,
+			aliases: lang.aliases
+		};
+		if (lang.aliases) for (const alias of lang.aliases) languagesCache[alias] = {
+			name,
+			wasm: lang.wasm,
+			queries: lang.queries,
+			extensions: lang.extensions,
+			aliases: lang.aliases
+		};
+	}
+	return languagesCache;
+}
+function buildExtensionMap() {
+	if (extensionMapCache) return extensionMapCache;
+	const languages = buildLanguages();
+	extensionMapCache = {};
+	for (const config$1 of Object.values(languages)) for (const ext of config$1.extensions) extensionMapCache[ext] = config$1;
+	return extensionMapCache;
+}
+/** Get language configuration from file path */
+function getLanguageFromPath(filePath) {
+	const ext = filePath.slice(filePath.lastIndexOf(".")).toLowerCase();
+	return buildExtensionMap()[ext];
+}
+/** Get language configuration by name */
+function getLanguageByName(name) {
+	return buildLanguages()[name.toLowerCase()];
+}
+/** Clear caches (for testing) */
+function clearLanguageCache$1() {
+	configCache$1 = null;
+	languagesCache = null;
+	extensionMapCache = null;
+}
+const LANGUAGES = buildLanguages();
+const EXTENSION_MAP = buildExtensionMap();
+registerCache("languages:config", clearLanguageCache$1);
+
+//#endregion
+//#region src/core/parser/index.ts
+/**
+* Tree-sitter parser module
+*
+* Provides code parsing functionality using web-tree-sitter
+* WASM files are loaded from local assets directory for minimal bundle size
+*/
+/**
+* Parser initialization state
+*/
+let isInitialized = false;
+let initPromise = null;
+/**
+* Cache for loaded languages
+*/
+const languageCache = /* @__PURE__ */ new Map();
+/**
+* Parser instance (reused)
+*/
+let parser = null;
+/**
+* Initialize the Tree-sitter WASM module
+* Must be called before any parsing operations
+*/
+async function initializeParser() {
+	if (isInitialized) return;
+	if (initPromise) return initPromise;
+	initPromise = (async () => {
+		await Parser.init();
+		parser = new Parser();
+		isInitialized = true;
+	})();
+	return initPromise;
+}
+/**
+* Get or create a parser instance
+*/
+async function getParser() {
+	await initializeParser();
+	if (!parser) throw new Error("Parser not initialized");
+	return parser;
+}
+/**
+* Load a language grammar from local assets
+*/
+async function loadLanguage(config$1) {
+	const cacheKey = config$1.name;
+	const cached = languageCache.get(cacheKey);
+	if (cached) return cached;
+	await initializeParser();
+	const wasmPath = join(getAssetsDir(), "wasm", `tree-sitter-${config$1.name}.wasm`);
+	if (!existsSync(wasmPath)) throw new Error(`WASM file not found for language ${config$1.name}: ${wasmPath}`);
+	const language = await Language.load(wasmPath);
+	languageCache.set(cacheKey, language);
+	return language;
+}
+/**
+* Parse code content
+*/
+async function parseCode(content, options = {}) {
+	const { language, filePath } = options;
+	let config$1;
+	if (language) {
+		config$1 = getLanguageByName(language);
+		if (!config$1) throw new Error(`Unsupported language: ${language}`);
+	} else if (filePath) {
+		config$1 = getLanguageFromPath(filePath);
+		if (!config$1) throw new Error(`Could not detect language for file: ${filePath}`);
+	} else throw new Error("Either language or filePath must be provided");
+	const languageInstance = await loadLanguage(config$1);
+	const parserInstance = await getParser();
+	parserInstance.setLanguage(languageInstance);
+	const tree = parserInstance.parse(content);
+	if (!tree) throw new Error("Failed to parse content");
+	return {
+		tree,
+		language: config$1.name,
+		parser: parserInstance,
+		languageInstance
+	};
+}
+/**
+* Convert Tree-sitter position to our Position type
+*/
+function toPosition(point, offset) {
+	return {
+		line: point.row + 1,
+		column: point.column,
+		offset
+	};
+}
+/**
+* Convert Tree-sitter node to ASTNode
+*/
+function toASTNode(node, maxDepth, currentDepth = 0) {
+	const astNode = {
+		type: node.type,
+		text: node.text,
+		start: toPosition(node.startPosition, node.startIndex),
+		end: toPosition(node.endPosition, node.endIndex),
+		isNamed: node.isNamed
+	};
+	if (maxDepth !== void 0 && currentDepth >= maxDepth) return astNode;
+	if (node.childCount > 0) {
+		const namedChildren = node.namedChildren;
+		if (namedChildren.length > 0) astNode.children = namedChildren.map((child) => toASTNode(child, maxDepth, currentDepth + 1));
+	}
+	const treeLang = node.tree.language;
+	const fields = {};
+	const langFields = treeLang.fields;
+	for (const fieldName of langFields) if (fieldName) {
+		const fieldNode = node.childForFieldName(fieldName);
+		if (fieldNode) fields[fieldName] = toASTNode(fieldNode, maxDepth, currentDepth + 1);
+	}
+	if (Object.keys(fields).length > 0) astNode.fields = fields;
+	return astNode;
+}
+/**
+* Clear the language cache (useful for testing)
+*/
+function clearLanguageCache() {
+	languageCache.clear();
+}
+/**
+* Reset the parser state (useful for testing)
+*/
+function resetParser() {
+	languageCache.clear();
+	parser = null;
+	isInitialized = false;
+	initPromise = null;
+}
+registerCache("parser:languageCache", clearLanguageCache);
+registerCache("parser:state", resetParser);
+
+//#endregion
+//#region src/core/queries/helpers.ts
+/**
+* Find a capture by exact name
+*
+* @param captures - Array of captures from a query match
+* @param name - Exact capture name to find
+* @returns The matching capture or undefined
+*/
+function findCapture(captures, name) {
+	return captures.find((c) => c.name === name);
+}
+/**
+* Find a capture matching any of the given names
+*
+* @param captures - Array of captures from a query match
+* @param names - Array of capture names to search for
+* @returns The first matching capture or undefined
+*/
+function findCaptureByNames(captures, names) {
+	return captures.find((c) => names.includes(c.name));
+}
+/**
+* Find a capture by name prefix
+*
+* @param captures - Array of captures from a query match
+* @param prefix - Prefix to match (e.g., "definition." matches "definition.function")
+* @returns The first matching capture or undefined
+*/
+function findCaptureByPrefix(captures, prefix) {
+	return captures.find((c) => c.name.startsWith(prefix));
+}
+/**
+* Extract the suffix from a capture name after the prefix
+*
+* @param captureName - Full capture name (e.g., "definition.function")
+* @param prefix - Prefix to remove (e.g., "definition.")
+* @returns The suffix (e.g., "function") or the original name if prefix not found
+*/
+function getCaptureKind(captureName, prefix) {
+	return captureName.startsWith(prefix) ? captureName.slice(prefix.length) : captureName;
+}
+/**
+* Create a deduplication set from node offsets
+*
+* @returns Object with add and has methods for tracking seen offsets
+*/
+function createOffsetTracker() {
+	const seen = /* @__PURE__ */ new Set();
+	return {
+		add: (node) => seen.add(node.start.offset),
+		has: (node) => seen.has(node.start.offset)
+	};
+}
+
+//#endregion
+//#region src/core/queries/loader.ts
+/**
+* SCM Query file loader
+*
+* Loads official Tree-sitter .scm query files from local assets directory
+* Supports inheritance via `; inherits: lang1,lang2` directives
+*/
+/**
+* Cache for loaded SCM queries (with inheritance resolved)
+*/
+const scmCache = /* @__PURE__ */ new Map();
+/**
+* Normalize language name for directory lookup
+*/
+function normalizeLanguageName(language) {
+	if (language === "csharp") return "c_sharp";
+	if (language === "tsx") return "typescript";
+	return language;
+}
+/**
+* Get the path to a .scm query file
+*/
+function getSCMPath(language, queryType) {
+	const relativePath = join("queries", normalizeLanguageName(language), `${queryType}.scm`);
+	if (assetExists(relativePath)) return join(getAssetsDir(), relativePath);
+}
+/**
+* Parse inherit directives from SCM content
+* Supports: `; inherits: lang1,lang2` and `; inherits lang1`
+*/
+function parseInherits(content) {
+	const inherits = [];
+	const lines = content.replace(/\r\n/g, "\n").replace(/\r/g, "\n").split("\n");
+	for (const line of lines) {
+		const match = /^;\s*inherits:?\s+([^\s].*)$/.exec(line);
+		if (match?.[1]) {
+			const langs = match[1].split(",").map((l) => l.trim());
+			inherits.push(...langs);
+		}
+	}
+	return inherits;
+}
+/**
+* Remove inherit directives from SCM content
+*/
+function removeInheritDirectives(content) {
+	return content.replace(/\r\n/g, "\n").replace(/\r/g, "\n").split("\n").filter((line) => !/^;\s*inherits:?\s+/.exec(line)).join("\n");
+}
+/**
+* Load a raw .scm file without resolving inheritance
+*/
+function loadRawSCM(language, queryType) {
+	const scmPath = join(getAssetsDir(), "queries", language, `${queryType}.scm`);
+	if (!existsSync(scmPath)) return;
+	try {
+		return readFileSync(scmPath, "utf-8");
+	} catch {
+		return;
+	}
+}
+/**
+* Load a .scm query file for a language with inheritance resolved
+*
+* @param language - Language name (e.g., "javascript", "python")
+* @param queryType - Type of query (e.g., "tags", "highlights")
+* @param visited - Set of visited languages to prevent circular inheritance
+* @returns Query string or undefined if not found
+*/
+function loadSCMQuery(language, queryType, visited = /* @__PURE__ */ new Set()) {
+	const cacheKey = `${language}:${queryType}`;
+	if (scmCache.has(cacheKey)) return scmCache.get(cacheKey);
+	if (visited.has(language)) return;
+	visited.add(language);
+	const rawContent = loadRawSCM(normalizeLanguageName(language), queryType);
+	if (!rawContent) return;
+	const inherits = parseInherits(rawContent);
+	const ownContent = removeInheritDirectives(rawContent).trim();
+	const inheritedParts = [];
+	for (const inheritLang of inherits) {
+		const inheritedContent = loadSCMQuery(inheritLang, queryType, visited);
+		if (inheritedContent) inheritedParts.push(inheritedContent);
+	}
+	const finalContent = [...inheritedParts, ownContent].filter(Boolean).join("\n\n");
+	if (finalContent) scmCache.set(cacheKey, finalContent);
+	return finalContent || void 0;
+}
+/**
+* Load tags.scm for symbol extraction
+*/
+function loadTagsQuery(language) {
+	return loadSCMQuery(language, "tags");
+}
+/**
+* Load highlights.scm for syntax highlighting
+*/
+function loadHighlightsQuery(language) {
+	return loadSCMQuery(language, "highlights");
+}
+/**
+* Load locals.scm for local variable scoping
+*/
+function loadLocalsQuery(language) {
+	return loadSCMQuery(language, "locals");
+}
+/**
+* Check if a language has official tags.scm
+*/
+function hasOfficialTags(language) {
+	return getSCMPath(language, "tags") !== void 0;
+}
+/**
+* Clear the SCM cache
+*/
+function clearSCMCache() {
+	scmCache.clear();
+}
+registerCache("queries:scm", clearSCMCache);
+
+//#endregion
+//#region src/core/queries/patterns.ts
+const GENERIC_PATTERNS = {
+	comments: `[(comment) @comment]`,
+	strings: `[(string) @string (template_string) @string]`,
+	imports: `(import_statement) @import.statement`,
+	exports: `(export_statement) @export.statement`,
+	variables: `[
+    (variable_declaration (variable_declarator name: (identifier) @variable.name) @variable.declaration)
+    (lexical_declaration (variable_declarator name: (identifier) @variable.name) @variable.declaration)
+  ]`,
+	types: `[
+    (type_alias_declaration name: (type_identifier) @type.alias) @type.definition
+    (enum_declaration name: (identifier) @enum.name) @enum.definition
+  ]`
+};
+const FALLBACK_PATTERNS = {
+	typescript: { functions: `[
+      (function_declaration name: (identifier) @function.name) @function.definition
+      (method_definition name: (property_identifier) @function.name) @function.definition
+      (lexical_declaration (variable_declarator name: (identifier) @function.name value: [(arrow_function) (function_expression)]) @function.definition)
+    ]` },
+	json: { strings: `[(string) @string]` },
+	yaml: {
+		strings: `[(string_scalar) @string (double_quote_scalar) @string (single_quote_scalar) @string]`,
+		comments: `[(comment) @comment]`
+	},
+	toml: {
+		strings: `[(string) @string]`,
+		comments: `[(comment) @comment]`
+	},
+	bash: {
+		functions: `(function_definition name: (word) @function.name) @function.definition`,
+		comments: `[(comment) @comment]`,
+		strings: `[(string) @string (raw_string) @string]`,
+		variables: `(variable_assignment name: (variable_name) @variable.name) @variable.declaration`
+	},
+	html: {
+		strings: `[(attribute_value) @string (quoted_attribute_value) @string]`,
+		comments: `[(comment) @comment]`
+	},
+	css: {
+		comments: `[(comment) @comment]`,
+		strings: `[(string_value) @string]`
+	},
+	scala: {
+		functions: `(function_definition (identifier) @function.name) @function.definition`,
+		classes: `[
+      (class_definition (identifier) @class.name) @class.definition
+      (object_definition (identifier) @class.name) @class.definition
+      (trait_definition (identifier) @class.name) @class.definition
+    ]`,
+		comments: `[(comment) @comment]`,
+		strings: `[(string) @string]`
+	},
+	swift: {
+		functions: `[
+      (function_declaration (simple_identifier) @function.name) @function.definition
+      (init_declaration) @function.definition
+    ]`,
+		classes: `[
+      (class_declaration (type_identifier) @class.name) @class.definition
+      (protocol_declaration (type_identifier) @class.name) @class.definition
+    ]`,
+		comments: `[(comment) @comment (multiline_comment) @comment]`,
+		strings: `[(line_string_literal) @string]`
+	},
+	ocaml: {
+		functions: `(value_definition (let_binding (value_name) @function.name)) @function.definition`,
+		classes: `[
+      (type_definition (type_binding (type_constructor) @class.name)) @class.definition
+      (module_definition (module_binding (module_name) @class.name)) @class.definition
+    ]`,
+		comments: `[(comment) @comment]`,
+		strings: `[(string) @string]`
+	},
+	svelte: {
+		comments: `[(comment) @comment]`,
+		strings: `[(attribute_value) @string (quoted_attribute_value) @string]`
+	}
+};
+function getQueryPattern(language, preset) {
+	return FALLBACK_PATTERNS[language]?.[preset] ?? GENERIC_PATTERNS[preset];
+}
+
+//#endregion
+//#region src/core/queries/index.ts
+/**
+* SCM Query engine for Tree-sitter
+*
+* Supports both official .scm query files and custom preset patterns
+*/
+/**
+* Execute a SCM query on parsed code
+*/
+function executeQuery(tree, languageInstance, queryString, language, options = {}) {
+	const { maxMatches, startIndex, endIndex } = options;
+	let query;
+	try {
+		query = new Query(languageInstance, queryString);
+	} catch (error) {
+		const message = error instanceof Error ? error.message : String(error);
+		throw new Error(`Invalid query: ${message}`);
+	}
+	const queryMatches = query.matches(tree.rootNode, {
+		startIndex,
+		endIndex
+	});
+	const matches = [];
+	let count = 0;
+	for (const match of queryMatches) {
+		if (maxMatches !== void 0 && count >= maxMatches) break;
+		const captures = match.captures.map((capture) => ({
+			name: capture.name,
+			node: toASTNode(capture.node)
+		}));
+		matches.push({
+			pattern: match.patternIndex,
+			captures
+		});
+		count++;
+	}
+	return {
+		matches,
+		count,
+		query: queryString,
+		language,
+		source: "preset"
+	};
+}
+/**
+* Execute an official .scm query file
+*
+* @param tree - Parsed tree
+* @param languageInstance - Tree-sitter language instance
+* @param language - Language name
+* @param queryType - Type of query (tags, highlights, locals, etc.)
+* @param options - Query options
+*/
+function executeOfficialQuery(tree, languageInstance, language, queryType, options = {}) {
+	let queryString;
+	switch (queryType) {
+		case "tags":
+			queryString = loadTagsQuery(language);
+			break;
+		case "highlights":
+			queryString = loadHighlightsQuery(language);
+			break;
+		case "locals":
+			queryString = loadLocalsQuery(language);
+			break;
+		case "injections":
+		case "indents":
+		case "folds": return;
+	}
+	if (!queryString) return;
+	try {
+		return {
+			...executeQuery(tree, languageInstance, queryString, language, options),
+			source: "official"
+		};
+	} catch {
+		return;
+	}
+}
+/**
+* Execute tags.scm for comprehensive symbol extraction
+*
+* This uses the official Tree-sitter tags.scm file which provides:
+* - Function definitions with documentation
+* - Class definitions
+* - Method definitions
+* - Module/interface definitions
+* - Reference tracking (calls, types)
+*/
+function executeTagsQuery(tree, languageInstance, language, options = {}) {
+	return executeOfficialQuery(tree, languageInstance, language, "tags", options);
+}
+/**
+* Execute a preset query
+* Uses official tags.scm for functions/classes when available,
+* otherwise falls back to preset patterns
+*/
+function executePresetQuery(tree, languageInstance, language, preset, options = {}) {
+	const { maxMatches } = options;
+	const fallbackPattern = getQueryPattern(language, preset);
+	if (preset === "functions" || preset === "classes") {
+		if (hasOfficialTags(language)) {
+			const { definitions } = extractSymbolsFromTags(tree, languageInstance, language);
+			let filteredDefs = preset === "functions" ? definitions.filter((d) => d.kind === "function" || d.kind === "method") : definitions.filter((d) => d.kind === "class" || d.kind === "interface" || d.kind === "module");
+			if (filteredDefs.length > 0) {
+				if (maxMatches !== void 0 && filteredDefs.length > maxMatches) filteredDefs = filteredDefs.slice(0, maxMatches);
+				const matches = filteredDefs.map((def) => ({
+					pattern: 0,
+					captures: [{
+						name: preset === "functions" ? "function.definition" : "class.definition",
+						node: def.node
+					}, {
+						name: `${preset.slice(0, -1)}.name`,
+						node: def.nameNode
+					}]
+				}));
+				return {
+					matches,
+					count: matches.length,
+					query: `[tags.scm ${preset}]`,
+					language,
+					source: "official"
+				};
+			}
+			if (fallbackPattern) return executeQuery(tree, languageInstance, fallbackPattern, language, options);
+			return {
+				matches: [],
+				count: 0,
+				query: `[tags.scm ${preset}]`,
+				language,
+				source: "official"
+			};
+		}
+		if (fallbackPattern) return executeQuery(tree, languageInstance, fallbackPattern, language, options);
+	}
+	if (!fallbackPattern) throw new Error(`No '${preset}' query pattern available for ${language}`);
+	return executeQuery(tree, languageInstance, fallbackPattern, language, options);
+}
+/**
+* Extract symbols using official tags.scm when available
+*
+* This is the recommended method for symbol extraction as it uses
+* the official Tree-sitter query files for better accuracy.
+*/
+function extractSymbolsFromTags(tree, languageInstance, language) {
+	const result = executeTagsQuery(tree, languageInstance, language);
+	if (!result) return {
+		definitions: [],
+		references: []
+	};
+	const definitions = [];
+	const references = [];
+	for (const match of result.matches) {
+		const nameCapture = findCapture(match.captures, "name");
+		if (!nameCapture) continue;
+		const defCapture = findCaptureByPrefix(match.captures, "definition.");
+		const refCapture = findCaptureByPrefix(match.captures, "reference.");
+		const docCapture = findCapture(match.captures, "doc");
+		if (defCapture) {
+			const kind = getCaptureKind(defCapture.name, "definition.");
+			definitions.push({
+				name: nameCapture.node.text,
+				kind,
+				node: defCapture.node,
+				nameNode: nameCapture.node,
+				documentation: docCapture?.node.text
+			});
+		} else if (refCapture) {
+			const kind = getCaptureKind(refCapture.name, "reference.");
+			references.push({
+				name: nameCapture.node.text,
+				kind,
+				node: refCapture.node,
+				nameNode: nameCapture.node
+			});
+		}
+	}
+	return {
+		definitions,
+		references
+	};
+}
+/**
+* Get function name from a function node
+*/
+function getFunctionName(funcNode) {
+	if (funcNode.fields?.name) {
+		const nameNode = funcNode.fields.name;
+		if (!Array.isArray(nameNode)) return nameNode.text;
+	}
+	if (funcNode.children) for (const child of funcNode.children) {
+		if (child.type === "identifier" || child.type === "property_identifier" || child.type === "field_identifier") return child.text;
+		if (child.type === "function_declarator") return getFunctionName(child);
+	}
+}
+/**
+* Get class name from a class node
+*/
+function getClassName(classNode) {
+	if (classNode.fields?.name) {
+		const nameNode = classNode.fields.name;
+		if (!Array.isArray(nameNode)) return nameNode.text;
+	}
+	if (classNode.children) {
+		for (const child of classNode.children) if (child.type === "identifier" || child.type === "type_identifier") return child.text;
+	}
+}
+
+//#endregion
+//#region src/core/symbols/index.ts
+/**
+* Extract symbols from parsed code
+*/
+function extractSymbols(tree, languageInstance, language, filter = {}) {
+	const symbols = [];
+	const { types, excludeTypes } = filter;
+	const shouldInclude = (type) => {
+		if (types && !types.includes(type)) return false;
+		if (excludeTypes?.includes(type)) return false;
+		return true;
+	};
+	if (shouldInclude("function") || shouldInclude("method") || shouldInclude("class") || shouldInclude("interface")) {
+		const tagsResult = executePresetQuery(tree, languageInstance, language, "functions");
+		if (shouldInclude("function") || shouldInclude("method")) for (const match of tagsResult.matches) {
+			const defCapture = findCapture(match.captures, "function.definition");
+			const nameCapture = findCapture(match.captures, "function.name");
+			if (defCapture) {
+				const name = nameCapture?.node.text ?? getFunctionName(defCapture.node);
+				if (name) {
+					const type = defCapture.node.type.includes("method") || defCapture.node.type === "method_definition" ? "method" : "function";
+					if (shouldInclude(type)) symbols.push({
+						name,
+						type,
+						start: defCapture.node.start,
+						end: defCapture.node.end,
+						signature: extractFunctionSignature(defCapture.node),
+						modifiers: extractModifiers(defCapture.node)
+					});
+				}
+			}
+		}
+	}
+	if (shouldInclude("class") || shouldInclude("interface")) {
+		const classResult = executePresetQuery(tree, languageInstance, language, "classes");
+		for (const match of classResult.matches) {
+			const defCapture = findCapture(match.captures, "class.definition");
+			const nameCapture = findCapture(match.captures, "class.name");
+			if (defCapture) {
+				const name = nameCapture?.node.text ?? getClassName(defCapture.node);
+				if (name) {
+					const nodeType = defCapture.node.type;
+					let symbolType = "class";
+					if (nodeType.includes("interface") || nodeType === "interface_declaration") symbolType = "interface";
+					else if (nodeType.includes("struct")) symbolType = "interface";
+					if (shouldInclude(symbolType)) symbols.push({
+						name,
+						type: symbolType,
+						start: defCapture.node.start,
+						end: defCapture.node.end,
+						modifiers: extractModifiers(defCapture.node)
+					});
+				}
+			}
+		}
+	}
+	if (shouldInclude("variable") || shouldInclude("constant")) try {
+		const varResult = executePresetQuery(tree, languageInstance, language, "variables");
+		for (const match of varResult.matches) {
+			const nameCapture = findCaptureByNames(match.captures, [
+				"variable.name",
+				"constant.name",
+				"field.name"
+			]);
+			const declCapture = findCaptureByNames(match.captures, [
+				"variable.declaration",
+				"constant.declaration",
+				"field.declaration"
+			]);
+			if (nameCapture && declCapture) {
+				const type = declCapture.node.text.startsWith("const ") || findCapture(match.captures, "constant.name") !== void 0 ? "constant" : "variable";
+				if (shouldInclude(type)) symbols.push({
+					name: nameCapture.node.text,
+					type,
+					start: declCapture.node.start,
+					end: declCapture.node.end,
+					modifiers: extractModifiers(declCapture.node)
+				});
+			}
+		}
+	} catch {}
+	if (shouldInclude("interface") || shouldInclude("type") || shouldInclude("enum")) try {
+		const typeResult = executePresetQuery(tree, languageInstance, language, "types");
+		for (const match of typeResult.matches) {
+			const nameCapture = findCaptureByNames(match.captures, [
+				"type.name",
+				"interface.name",
+				"enum.name",
+				"type.alias"
+			]);
+			const defCapture = findCaptureByNames(match.captures, [
+				"type.definition",
+				"interface.definition",
+				"enum.definition"
+			]);
+			if (nameCapture && defCapture) {
+				let type = "type";
+				if (nameCapture.name === "interface.name") type = "interface";
+				else if (nameCapture.name === "enum.name") type = "enum";
+				if (shouldInclude(type)) symbols.push({
+					name: nameCapture.node.text,
+					type,
+					start: defCapture.node.start,
+					end: defCapture.node.end,
+					modifiers: extractModifiers(defCapture.node)
+				});
+			}
+		}
+	} catch {}
+	return {
+		symbols,
+		summary: {
+			functions: symbols.filter((s) => s.type === "function").length,
+			classes: symbols.filter((s) => s.type === "class").length,
+			variables: symbols.filter((s) => s.type === "variable").length,
+			constants: symbols.filter((s) => s.type === "constant").length,
+			interfaces: symbols.filter((s) => s.type === "interface").length,
+			types: symbols.filter((s) => s.type === "type").length,
+			enums: symbols.filter((s) => s.type === "enum").length,
+			methods: symbols.filter((s) => s.type === "method").length,
+			properties: symbols.filter((s) => s.type === "property").length,
+			total: symbols.length
+		}
+	};
+}
+/**
+* Extract function signature from AST node
+*/
+function extractFunctionSignature(node) {
+	const text = node.text;
+	const jsMatch = /^(async\s+)?function\s*\*?\s*(\w*)\s*(<[^>]*>)?\s*\([^)]*\)(\s*:\s*[^{]+)?/.exec(text);
+	if (jsMatch) return jsMatch[0].trim();
+	const arrowMatch = /^\([^)]*\)\s*(:\s*[^=]+)?\s*=>/.exec(text);
+	if (arrowMatch) return arrowMatch[0].trim();
+	const pyMatch = /^def\s+(\w+)\s*\([^)]*\)(\s*->\s*[^:]+)?:/.exec(text);
+	if (pyMatch) return pyMatch[0].replace(/:$/, "").trim();
+	const goMatch = /^func\s*(\([^)]*\)\s*)?(\w+)\s*\([^)]*\)/.exec(text);
+	if (goMatch) return goMatch[0].trim();
+	const firstLine = text.split(/[{:]/)[0];
+	return firstLine ? firstLine.trim() : void 0;
+}
+/**
+* Extract modifiers from AST node
+*/
+function extractModifiers(node) {
+	const modifiers = [];
+	const text = node.text;
+	for (const mod of [
+		"export",
+		"default",
+		"async",
+		"static",
+		"public",
+		"private",
+		"protected",
+		"readonly",
+		"abstract",
+		"const",
+		"let",
+		"var",
+		"final",
+		"override",
+		"pub",
+		"mut"
+	]) if ((/* @__PURE__ */ new RegExp(`\\b${mod}\\b`)).test(text.slice(0, 100))) modifiers.push(mod);
+	return modifiers.length > 0 ? modifiers : void 0;
+}
+/**
+* Extract imports from parsed code
+*/
+function extractImports(tree, languageInstance, language) {
+	const imports = [];
+	try {
+		const result = executePresetQuery(tree, languageInstance, language, "imports");
+		const tracker = createOffsetTracker();
+		for (const match of result.matches) {
+			const stmtCapture = findCaptureByNames(match.captures, ["import.statement", "include.statement"]);
+			if (!stmtCapture || tracker.has(stmtCapture.node)) continue;
+			tracker.add(stmtCapture.node);
+			const sourceCapture = findCaptureByNames(match.captures, [
+				"import.source",
+				"import.path",
+				"include.path"
+			]);
+			const defaultCapture = findCapture(match.captures, "import.default");
+			const nameCaptures = match.captures.filter((c) => c.name === "import.name");
+			const source = sourceCapture ? sourceCapture.node.text.replace(/['"]/g, "") : "";
+			const names = [];
+			if (defaultCapture) names.push({ name: defaultCapture.node.text });
+			for (const nameCapture of nameCaptures) names.push({ name: nameCapture.node.text });
+			imports.push({
+				source,
+				names,
+				isDefault: !!defaultCapture && nameCaptures.length === 0,
+				start: stmtCapture.node.start,
+				end: stmtCapture.node.end
+			});
+		}
+	} catch {}
+	return imports;
+}
+/**
+* Extract exports from parsed code
+*/
+function extractExports(tree, languageInstance, language) {
+	const exportList = [];
+	try {
+		const result = executePresetQuery(tree, languageInstance, language, "exports");
+		const tracker = createOffsetTracker();
+		for (const match of result.matches) {
+			const stmtCapture = findCaptureByNames(match.captures, [
+				"export.statement",
+				"export.function",
+				"export.class",
+				"export.type"
+			]);
+			if (!stmtCapture || tracker.has(stmtCapture.node)) continue;
+			tracker.add(stmtCapture.node);
+			const nameCapture = findCapture(match.captures, "export.name");
+			const text = stmtCapture.node.text;
+			const isDefault = text.includes("export default");
+			let name = nameCapture?.node.text;
+			if (!name) {
+				const nameMatch = /export\s+(?:default\s+)?(?:function|class|const|let|var|interface|type|enum)\s+(\w+)/.exec(text);
+				if (nameMatch?.[1]) name = nameMatch[1];
+			}
+			exportList.push({
+				name: name ?? "default",
+				isDefault,
+				start: stmtCapture.node.start,
+				end: stmtCapture.node.end
+			});
+		}
+	} catch {}
+	return exportList;
+}
+
+//#endregion
+//#region src/core/embeddings/chunker.ts
+/**
+* Code chunker for splitting source files into embeddable chunks
+*
+* Uses tree-sitter for semantic chunking based on symbols (functions, classes, etc.)
+* This produces much better embeddings than character-based splitting.
+*/
+/**
+* Generate a unique ID for a chunk
+*/
+function generateChunkId(filePath, content, startLine) {
+	return `chunk_${crypto.createHash("md5").update(`${filePath}:${String(startLine)}:${content}`).digest("hex").slice(0, 12)}`;
+}
+/**
+* Detect language from file extension
+*/
+function detectLanguage(filePath) {
+	return {
+		ts: "typescript",
+		tsx: "typescript",
+		js: "javascript",
+		jsx: "javascript",
+		mjs: "javascript",
+		cjs: "javascript",
+		py: "python",
+		rs: "rust",
+		go: "go",
+		java: "java",
+		kt: "kotlin",
+		rb: "ruby",
+		php: "php",
+		c: "c",
+		cpp: "cpp",
+		h: "c",
+		hpp: "cpp",
+		cs: "csharp",
+		swift: "swift",
+		scala: "scala",
+		vue: "vue",
+		svelte: "svelte",
+		md: "markdown",
+		json: "json",
+		yaml: "yaml",
+		yml: "yaml",
+		toml: "toml",
+		xml: "xml",
+		html: "html",
+		css: "css",
+		scss: "scss",
+		less: "less",
+		sql: "sql",
+		sh: "bash",
+		bash: "bash",
+		zsh: "bash"
+	}[filePath.split(".").pop()?.toLowerCase() ?? ""] ?? "unknown";
+}
+/**
+* Get line number from byte offset
+*/
+function getLineFromOffset(content, offset) {
+	return (content.slice(0, offset).match(/\n/g) ?? []).length + 1;
+}
+/**
+* Extract code content for a symbol using its offsets
+*/
+function getSymbolContent(content, symbol) {
+	return content.slice(symbol.start.offset, symbol.end.offset);
+}
+/**
+* Split large content into smaller chunks while respecting line boundaries
+*/
+function splitLargeContent(content, maxSize, overlap) {
+	const normalizedContent = content.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+	if (normalizedContent.length <= maxSize) return [normalizedContent];
+	const chunks = [];
+	const lines = normalizedContent.split("\n");
+	let currentChunk = [];
+	let currentSize = 0;
+	for (const line of lines) {
+		const lineSize = line.length + 1;
+		if (currentSize + lineSize > maxSize && currentChunk.length > 0) {
+			chunks.push(currentChunk.join("\n"));
+			const overlapLines = [];
+			let overlapSize = 0;
+			for (let i = currentChunk.length - 1; i >= 0 && overlapSize < overlap; i--) {
+				const l = currentChunk[i];
+				if (l !== void 0) {
+					overlapLines.unshift(l);
+					overlapSize += l.length + 1;
+				}
+			}
+			currentChunk = overlapLines;
+			currentSize = overlapSize;
+		}
+		currentChunk.push(line);
+		currentSize += lineSize;
+	}
+	if (currentChunk.length > 0) chunks.push(currentChunk.join("\n"));
+	return chunks;
+}
+/**
+* Create a chunk from content
+*/
+function createChunk(filePath, language, content, startLine, endLine, symbolName, symbolType) {
+	return {
+		id: generateChunkId(filePath, content, startLine),
+		content,
+		filePath,
+		language,
+		startLine,
+		endLine,
+		symbolName,
+		symbolType
+	};
+}
+/**
+* Chunk a source file using tree-sitter for semantic boundaries
+*
+* Strategy:
+* 1. Parse file with tree-sitter and extract symbols
+* 2. Each function/class/method becomes its own chunk
+* 3. Code between symbols (imports, top-level code) is grouped together
+* 4. Large symbols are split at line boundaries if they exceed maxSize
+*/
+async function chunkFile(filePath, content, config$1) {
+	const language = detectLanguage(filePath);
+	const maxSize = config$1.defaultChunkSize;
+	const overlap = config$1.defaultChunkOverlap;
+	let symbols = [];
+	try {
+		const parseResult = await parseCode(content, { filePath });
+		symbols = extractSymbols(parseResult.tree, parseResult.languageInstance, parseResult.language).symbols;
+	} catch (error) {
+		logger.debug(`Tree-sitter parsing failed for ${filePath}, using fallback chunking: ${error instanceof Error ? error.message : String(error)}`);
+		return fallbackChunk(filePath, content, language, maxSize, overlap);
+	}
+	if (symbols.length === 0) return fallbackChunk(filePath, content, language, maxSize, overlap);
+	const sortedSymbols = [...symbols].sort((a, b) => a.start.offset - b.start.offset);
+	const regions = [];
+	let lastEndOffset = 0;
+	for (const symbol of sortedSymbols) {
+		if (symbol.start.offset > lastEndOffset) {
+			if (content.slice(lastEndOffset, symbol.start.offset).trim().length > 0) regions.push({
+				content: content.slice(lastEndOffset, symbol.start.offset),
+				startOffset: lastEndOffset,
+				endOffset: symbol.start.offset,
+				startLine: getLineFromOffset(content, lastEndOffset),
+				endLine: getLineFromOffset(content, symbol.start.offset)
+			});
+		}
+		const symbolContent = getSymbolContent(content, symbol);
+		regions.push({
+			content: symbolContent,
+			startOffset: symbol.start.offset,
+			endOffset: symbol.end.offset,
+			startLine: symbol.start.line,
+			endLine: symbol.end.line,
+			symbolName: symbol.name,
+			symbolType: symbol.type
+		});
+		lastEndOffset = Math.max(lastEndOffset, symbol.end.offset);
+	}
+	if (lastEndOffset < content.length) {
+		if (content.slice(lastEndOffset).trim().length > 0) regions.push({
+			content: content.slice(lastEndOffset),
+			startOffset: lastEndOffset,
+			endOffset: content.length,
+			startLine: getLineFromOffset(content, lastEndOffset),
+			endLine: getLineFromOffset(content, content.length)
+		});
+	}
+	const chunks = [];
+	for (const region of regions) {
+		const regionContent = region.content.trim();
+		if (regionContent.length === 0) continue;
+		if (regionContent.length <= maxSize) chunks.push(createChunk(filePath, language, regionContent, region.startLine, region.endLine, region.symbolName, region.symbolType));
+		else {
+			const parts = splitLargeContent(regionContent, maxSize, overlap);
+			let currentLine = region.startLine;
+			for (const part of parts) {
+				const partLines = (part.match(/\n/g) ?? []).length + 1;
+				chunks.push(createChunk(filePath, language, part, currentLine, currentLine + partLines - 1, region.symbolName, region.symbolType));
+				currentLine += partLines - Math.floor(overlap / 50);
+			}
+		}
+	}
+	return chunks;
+}
+/**
+* Fallback chunking when tree-sitter fails or finds no symbols
+* Uses simple line-based splitting
+*/
+function fallbackChunk(filePath, content, language, maxSize, overlap) {
+	if (content.trim().length === 0) return [];
+	const chunks = [];
+	const parts = splitLargeContent(content, maxSize, overlap);
+	let currentLine = 1;
+	for (const part of parts) {
+		const partLines = (part.match(/\n/g) ?? []).length + 1;
+		chunks.push(createChunk(filePath, language, part, currentLine, currentLine + partLines - 1));
+		currentLine += partLines - Math.floor(overlap / 50);
+	}
+	return chunks;
+}
+/**
+* Supported file extensions for indexing
+*/
+const SUPPORTED_EXTENSIONS = [
+	".ts",
+	".tsx",
+	".js",
+	".jsx",
+	".mjs",
+	".cjs",
+	".py",
+	".rs",
+	".go",
+	".java",
+	".kt",
+	".rb",
+	".php",
+	".c",
+	".cpp",
+	".h",
+	".hpp",
+	".cs",
+	".swift",
+	".scala",
+	".vue",
+	".svelte",
+	".md"
+];
+/**
+* Check if a file should be indexed
+*/
+function shouldIndexFile(filePath) {
+	const ext = "." + (filePath.split(".").pop()?.toLowerCase() ?? "");
+	return SUPPORTED_EXTENSIONS.includes(ext);
+}
+
+//#endregion
+//#region src/core/embeddings/crossfile.ts
+/**
+* Cross-file context resolution for enriched embeddings
+*
+* Resolves imports and includes relevant symbol definitions from
+* imported files to provide better context for semantic search.
+*/
+const resolvedFileCache = /* @__PURE__ */ new Map();
+/**
+* Clear the resolved file cache
+*/
+function clearCrossFileCache() {
+	resolvedFileCache.clear();
+}
+registerCache("embeddings:crossFileCache", clearCrossFileCache);
+/**
+* Common file extensions to try when resolving imports
+*/
+const EXTENSIONS = [
+	".ts",
+	".tsx",
+	".js",
+	".jsx",
+	".mjs",
+	".cjs"
+];
+/**
+* Resolve an import source to an absolute file path
+*/
+function resolveImportPath(importSource, currentFilePath, options) {
+	const { projectRoot, pathAliases = {} } = options;
+	if (!importSource.startsWith(".") && !importSource.startsWith("@") && !Object.keys(pathAliases).some((alias) => importSource.startsWith(alias))) return null;
+	let resolvedPath;
+	for (const [alias, target] of Object.entries(pathAliases)) if (importSource.startsWith(alias)) {
+		const relativePart = importSource.slice(alias.length);
+		resolvedPath = path.join(projectRoot, target, relativePart);
+		break;
+	}
+	if (resolvedPath === void 0) if (importSource.startsWith(".")) {
+		const currentDir = path.dirname(currentFilePath);
+		resolvedPath = path.resolve(currentDir, importSource);
+	} else return null;
+	for (const ext of EXTENSIONS) {
+		const withExt = resolvedPath + ext;
+		if (fs.existsSync(withExt) && fs.statSync(withExt).isFile()) return withExt;
+	}
+	if (fs.existsSync(resolvedPath) && fs.statSync(resolvedPath).isFile()) return resolvedPath;
+	for (const ext of EXTENSIONS) {
+		const indexPath = path.join(resolvedPath, `index${ext}`);
+		if (fs.existsSync(indexPath) && fs.statSync(indexPath).isFile()) return indexPath;
+	}
+	return null;
+}
+/**
+* Analyze a resolved file and extract its symbols
+*/
+async function analyzeResolvedFile(filePath) {
+	const cached = resolvedFileCache.get(filePath);
+	if (cached !== void 0) return cached;
+	try {
+		const parseResult = await parseCode(fs.readFileSync(filePath, "utf-8"), { filePath });
+		const { symbols } = extractSymbols(parseResult.tree, parseResult.languageInstance, parseResult.language);
+		const result = {
+			symbols,
+			exports: extractExports(parseResult.tree, parseResult.languageInstance, parseResult.language)
+		};
+		resolvedFileCache.set(filePath, result);
+		return result;
+	} catch (error) {
+		logger.debug(`Failed to analyze ${filePath}: ${error instanceof Error ? error.message : String(error)}`);
+		resolvedFileCache.set(filePath, null);
+		return null;
+	}
+}
+/**
+* Find symbols that match imported names
+*/
+function findImportedSymbols(importStatement, symbols, exports) {
+	const importedNames = /* @__PURE__ */ new Set();
+	for (const name of importStatement.names) importedNames.add(name.name);
+	if (importStatement.isNamespace) {
+		const exportedNames = new Set(exports.map((e) => e.name));
+		return symbols.filter((s) => exportedNames.has(s.name));
+	}
+	if (importStatement.isDefault) {
+		const defaultExport = exports.find((e) => e.isDefault);
+		if (defaultExport) importedNames.add(defaultExport.name);
+	}
+	return symbols.filter((s) => importedNames.has(s.name));
+}
+/**
+* Resolve imports and get cross-file context
+*/
+async function resolveCrossFileContext(imports, currentFilePath, options) {
+	const maxImports = options.maxImports ?? 10;
+	const maxSymbolsPerFile = options.maxSymbolsPerFile ?? 5;
+	const resolvedImports = [];
+	for (const imp of imports.slice(0, maxImports)) {
+		const resolvedPath = resolveImportPath(imp.source, currentFilePath, options);
+		if (!resolvedPath) {
+			resolvedImports.push({
+				import: imp,
+				resolvedPath: null,
+				symbols: [],
+				exports: []
+			});
+			continue;
+		}
+		const analysis = await analyzeResolvedFile(resolvedPath);
+		if (!analysis) {
+			resolvedImports.push({
+				import: imp,
+				resolvedPath,
+				symbols: [],
+				exports: []
+			});
+			continue;
+		}
+		const importedSymbols = findImportedSymbols(imp, analysis.symbols, analysis.exports).slice(0, maxSymbolsPerFile);
+		resolvedImports.push({
+			import: imp,
+			resolvedPath,
+			symbols: importedSymbols,
+			exports: analysis.exports
+		});
+	}
+	return {
+		resolvedImports,
+		importedSymbolsSummary: buildImportedSymbolsSummary(resolvedImports)
+	};
+}
+/**
+* Build a summary string of imported symbols for enrichment
+*/
+function buildImportedSymbolsSummary(resolvedImports) {
+	const lines = [];
+	for (const resolved of resolvedImports) {
+		if (resolved.symbols.length === 0) continue;
+		const symbolDescriptions = resolved.symbols.map((s) => {
+			if (s.signature) return `${s.name}: ${s.signature}`;
+			return `${s.name} (${s.type})`;
+		});
+		if (symbolDescriptions.length > 0) lines.push(`From ${resolved.import.source}: ${symbolDescriptions.join("; ")}`);
+	}
+	return lines.join("\n");
+}
+
+//#endregion
+//#region src/core/embeddings/enricher.ts
+/**
+* AST cache per file path to avoid re-parsing
+*/
+const astCache = /* @__PURE__ */ new Map();
+/**
+* Clear the AST cache
+*/
+function clearASTCache() {
+	astCache.clear();
+}
+registerCache("embeddings:astCache", clearASTCache);
+/** Maximum number of imports to include in enriched content */
+const MAX_IMPORTS = 10;
+/** Maximum number of exports to include in enriched content */
+const MAX_EXPORTS = 10;
+/**
+* Get or create file analysis from cache
+*/
+async function getFileAnalysis(filePath, content, options) {
+	const cached = astCache.get(filePath);
+	if (cached) return cached;
+	try {
+		const parseResult = await parseCode(content, { filePath });
+		const { symbols } = extractSymbols(parseResult.tree, parseResult.languageInstance, parseResult.language);
+		const imports = extractImports(parseResult.tree, parseResult.languageInstance, parseResult.language);
+		const analysis = {
+			parseResult,
+			symbols,
+			imports,
+			exports: extractExports(parseResult.tree, parseResult.languageInstance, parseResult.language)
+		};
+		if ((options?.includeCrossFileContext ?? ENRICHMENT_CONFIG.includeCrossFileContext) && imports.length > 0 && options?.projectRoot) try {
+			const crossFileContext = await resolveCrossFileContext(imports, filePath, {
+				projectRoot: options.projectRoot,
+				pathAliases: options.pathAliases,
+				maxImports: ENRICHMENT_CONFIG.maxImportsToResolve,
+				maxSymbolsPerFile: ENRICHMENT_CONFIG.maxSymbolsPerImport
+			});
+			analysis.crossFileContext = crossFileContext;
+			logger.debug(`Resolved cross-file context for ${filePath}: ${String(crossFileContext.resolvedImports.length)} imports`);
+		} catch (error) {
+			logger.debug(`Failed to resolve cross-file context for ${filePath}: ${error instanceof Error ? error.message : String(error)}`);
+		}
+		astCache.set(filePath, analysis);
+		return analysis;
+	} catch (error) {
+		logger.debug(`Failed to parse ${filePath}: ${error instanceof Error ? error.message : String(error)}`);
+		return null;
+	}
+}
+/**
+* Find symbols that overlap with a chunk's line range
+*/
+function findSymbolsInRange(symbols, startLine, endLine) {
+	const chunkSymbols = [];
+	for (const symbol of symbols) {
+		const symbolStart = symbol.start.line;
+		const symbolEnd = symbol.end.line;
+		if (symbolStart <= endLine && symbolEnd >= startLine) chunkSymbols.push({
+			name: symbol.name,
+			type: symbol.type,
+			signature: symbol.signature
+		});
+	}
+	return chunkSymbols;
+}
+/**
+* Format import sources for enrichment header
+*/
+function formatImportSources(imports) {
+	return imports.slice(0, MAX_IMPORTS).map((imp) => imp.source).filter((source) => source.length > 0).join(", ");
+}
+/**
+* Format export names for enrichment header
+*/
+function formatExportNames(exports) {
+	return exports.slice(0, MAX_EXPORTS).map((exp) => exp.name).filter((name) => name.length > 0 && name !== "default").join(", ");
+}
+/**
+* Format symbols for enrichment header
+*/
+function formatSymbols(symbols) {
+	return symbols.map((s) => `${s.name} (${s.type})`).join(", ");
+}
+/**
+* Build enriched content with metadata header
+*/
+function buildEnrichedContent(chunk, symbols, imports, exports, crossFileContext) {
+	const headerLines = [];
+	headerLines.push(`File: ${chunk.filePath}`);
+	headerLines.push(`Language: ${chunk.language}`);
+	if (symbols.length > 0) headerLines.push(`Symbols: ${formatSymbols(symbols)}`);
+	if (imports.length > 0) {
+		const importStr = formatImportSources(imports);
+		if (importStr.length > 0) headerLines.push(`Imports: ${importStr}`);
+	}
+	if (exports.length > 0) {
+		const exportStr = formatExportNames(exports);
+		if (exportStr.length > 0) headerLines.push(`Exports: ${exportStr}`);
+	}
+	if (crossFileContext && crossFileContext.importedSymbolsSummary.length > 0) headerLines.push(`Imported definitions:\n${crossFileContext.importedSymbolsSummary}`);
+	return headerLines.join("\n") + "\n\n---\n" + chunk.content;
+}
+/**
+* Enrich all chunks from a single file (optimized - parses once)
+*/
+async function enrichChunksFromFile(chunks, content, options) {
+	if (chunks.length === 0) return [];
+	const filePath = chunks[0]?.filePath;
+	if (!filePath) return chunks.map((chunk) => {
+		const basicHeader = `File: ${chunk.filePath}\nLanguage: ${chunk.language}\n\n---\n`;
+		return {
+			...chunk,
+			enrichedContent: basicHeader + chunk.content,
+			containedSymbols: [],
+			wasEnriched: false
+		};
+	});
+	const analysis = await getFileAnalysis(filePath, content, options);
+	if (!analysis) return chunks.map((chunk) => {
+		const basicHeader = `File: ${chunk.filePath}\nLanguage: ${chunk.language}\n\n---\n`;
+		return {
+			...chunk,
+			enrichedContent: basicHeader + chunk.content,
+			containedSymbols: [],
+			wasEnriched: false
+		};
+	});
+	return chunks.map((chunk) => {
+		const chunkSymbols = findSymbolsInRange(analysis.symbols, chunk.startLine, chunk.endLine);
+		const enrichedContent = buildEnrichedContent(chunk, chunkSymbols, analysis.imports, analysis.exports, analysis.crossFileContext);
+		return {
+			...chunk,
+			enrichedContent,
+			containedSymbols: chunkSymbols,
+			wasEnriched: true
+		};
+	});
+}
+
+//#endregion
+//#region src/core/embeddings/watcher.ts
+/**
+* File watcher for automatic index updates
+*
+* Features:
+* - SHA-256 hash comparison to detect real content changes
+* - Debounce (5s default) to handle rapid changes
+* - Persistent hash cache to avoid unnecessary re-indexing
+* - fast-glob for efficient file scanning
+*/
+/** Default debounce delay in milliseconds */
+const DEFAULT_DEBOUNCE_MS = 5e3;
+/** Cache file name for storing hashes */
+const HASH_CACHE_FILE$1 = ".src-index-hashes.json";
+var IndexWatcher = class {
+	directory;
+	config;
+	debounceMs;
+	ollamaClient;
+	vectorStore;
+	watcher = null;
+	ig;
+	isProcessing = false;
+	hashCache = {};
+	pendingChanges = /* @__PURE__ */ new Map();
+	operationQueue = [];
+	onReady;
+	onError;
+	onIndexed;
+	onRemoved;
+	constructor(options) {
+		this.directory = path.resolve(options.directory);
+		this.config = options.config;
+		this.debounceMs = options.debounceMs ?? DEFAULT_DEBOUNCE_MS;
+		this.ollamaClient = new OllamaClient(options.config);
+		this.vectorStore = new VectorStore(this.directory, options.config);
+		this.ig = this.createIgnoreFilter();
+		this.onReady = options.onReady;
+		this.onError = options.onError;
+		this.onIndexed = options.onIndexed;
+		this.onRemoved = options.onRemoved;
+		this.loadHashCache();
+	}
+	/**
+	* Compute SHA-256 hash of content
+	*/
+	computeHash(content) {
+		return crypto.createHash("sha256").update(content, "utf8").digest("hex");
+	}
+	/**
+	* Get hash cache file path
+	*/
+	getHashCachePath() {
+		return path.join(this.directory, ".src-index", HASH_CACHE_FILE$1);
+	}
+	/**
+	* Load hash cache from disk
+	*/
+	loadHashCache() {
+		const cachePath = this.getHashCachePath();
+		if (fs.existsSync(cachePath)) try {
+			const content = fs.readFileSync(cachePath, "utf-8");
+			this.hashCache = JSON.parse(content);
+			logger.debug(`Loaded ${String(Object.keys(this.hashCache).length)} cached hashes`);
+		} catch {
+			this.hashCache = {};
+		}
+	}
+	/**
+	* Save hash cache to disk
+	*/
+	saveHashCache() {
+		const cachePath = this.getHashCachePath();
+		const cacheDir = path.dirname(cachePath);
+		try {
+			if (!fs.existsSync(cacheDir)) fs.mkdirSync(cacheDir, { recursive: true });
+			fs.writeFileSync(cachePath, JSON.stringify(this.hashCache, null, 2));
+		} catch (err) {
+			const error = err instanceof Error ? err : new Error(String(err));
+			logger.debug(`Failed to save hash cache: ${error.message}`);
+		}
+	}
+	/**
+	* Check if file content has changed by comparing hashes
+	*/
+	hasContentChanged(filePath, content) {
+		const newHash = this.computeHash(content);
+		if (this.hashCache[filePath] === newHash) return false;
+		this.hashCache[filePath] = newHash;
+		return true;
+	}
+	/**
+	* Remove file from hash cache
+	*/
+	removeFromHashCache(filePath) {
+		const { [filePath]: _, ...rest } = this.hashCache;
+		this.hashCache = rest;
+	}
+	/**
+	* Create ignore filter from .gitignore
+	*/
+	createIgnoreFilter() {
+		const ig = ignore();
+		const gitignorePath = path.join(this.directory, ".gitignore");
+		if (fs.existsSync(gitignorePath)) try {
+			const content = fs.readFileSync(gitignorePath, "utf-8");
+			ig.add(content);
+		} catch {}
+		return ig;
+	}
+	/**
+	* Check if a file should be indexed
+	*/
+	shouldIndex(filePath) {
+		const relativePath = path.relative(this.directory, filePath).replace(/\\/g, "/");
+		if (relativePath.split("/").some((part) => part.startsWith("."))) return false;
+		if (this.ig.ignores(relativePath)) return false;
+		return shouldIndexFile(filePath);
+	}
+	/**
+	* Schedule a file change with debouncing
+	*/
+	scheduleChange(type, filePath) {
+		const existing = this.pendingChanges.get(filePath);
+		if (existing) clearTimeout(existing.timer);
+		const timer = setTimeout(() => {
+			this.pendingChanges.delete(filePath);
+			this.queueOperation(async () => this.processChange(type, filePath));
+		}, this.debounceMs);
+		this.pendingChanges.set(filePath, {
+			type,
+			filePath,
+			timer
+		});
+		logger.debug(`Scheduled ${type}: ${path.basename(filePath)} (${String(this.debounceMs)}ms)`);
+	}
+	/**
+	* Process a file change after debounce
+	*/
+	async processChange(type, filePath) {
+		if (type === "unlink") await this.removeFile(filePath);
+		else await this.indexFile(filePath);
+	}
+	/**
+	* Index a single file
+	*/
+	async indexFile(filePath) {
+		if (!this.shouldIndex(filePath)) return;
+		try {
+			const content = fs.readFileSync(filePath, "utf-8");
+			if (!this.hasContentChanged(filePath, content)) {
+				logger.debug(`Skipped (unchanged): ${path.basename(filePath)}`);
+				return;
+			}
+			const chunks = await chunkFile(filePath, content, this.config);
+			if (chunks.length === 0) return;
+			const enrichedChunks = await enrichChunksFromFile(chunks, content);
+			const texts = enrichedChunks.map((c) => c.enrichedContent);
+			const embeddings = await this.ollamaClient.embedBatch(texts);
+			const embeddedChunks = enrichedChunks.map((chunk, i) => ({
+				id: chunk.id,
+				content: chunk.content,
+				filePath: chunk.filePath,
+				language: chunk.language,
+				startLine: chunk.startLine,
+				endLine: chunk.endLine,
+				symbolName: chunk.symbolName,
+				symbolType: chunk.symbolType,
+				vector: embeddings[i] ?? []
+			}));
+			await this.vectorStore.deleteByFilePath(filePath);
+			await this.vectorStore.addChunks(embeddedChunks);
+			this.saveHashCache();
+			logger.debug(`Indexed: ${path.relative(this.directory, filePath)}`);
+			this.onIndexed?.(filePath);
+		} catch (err) {
+			const error = err instanceof Error ? err : new Error(String(err));
+			logger.error(`Failed to index ${filePath}: ${error.message}`);
+			this.onError?.(error);
+		}
+	}
+	/**
+	* Remove a file from the index
+	*/
+	async removeFile(filePath) {
+		try {
+			await this.vectorStore.deleteByFilePath(filePath);
+			this.removeFromHashCache(filePath);
+			this.saveHashCache();
+			logger.debug(`Removed: ${path.relative(this.directory, filePath)}`);
+			this.onRemoved?.(filePath);
+		} catch (err) {
+			const error = err instanceof Error ? err : new Error(String(err));
+			logger.error(`Failed to remove ${filePath}: ${error.message}`);
+			this.onError?.(error);
+		}
+	}
+	/**
+	* Queue an operation to prevent concurrent modifications
+	*/
+	queueOperation(operation) {
+		this.operationQueue.push(operation);
+		this.processQueue();
+	}
+	/**
+	* Process queued operations sequentially
+	*/
+	async processQueue() {
+		if (this.isProcessing) return;
+		this.isProcessing = true;
+		while (this.operationQueue.length > 0) {
+			const operation = this.operationQueue.shift();
+			if (operation) try {
+				await operation();
+			} catch (err) {
+				const error = err instanceof Error ? err : new Error(String(err));
+				logger.error(`Operation failed: ${error.message}`);
+			}
+		}
+		this.isProcessing = false;
+	}
+	/**
+	* Collect files using fast-glob
+	*/
+	async collectFilesWithGlob() {
+		return (await fg(`**/*.{${SUPPORTED_EXTENSIONS.map((ext) => ext.slice(1)).join(",")}}`, {
+			cwd: this.directory,
+			absolute: true,
+			ignore: ["**/.*", "**/.*/**"],
+			dot: false,
+			onlyFiles: true,
+			followSymbolicLinks: false
+		})).filter((file) => {
+			const relativePath = path.relative(this.directory, file).replace(/\\/g, "/");
+			return !this.ig.ignores(relativePath);
+		});
+	}
+	/**
+	* Perform full initial indexing
+	*/
+	async fullIndex() {
+		logger.info("Starting full index...");
+		const files = await this.collectFilesWithGlob();
+		let indexed = 0;
+		let skipped = 0;
+		for (const filePath of files) try {
+			const content = fs.readFileSync(filePath, "utf-8");
+			if (!this.hasContentChanged(filePath, content)) {
+				skipped++;
+				continue;
+			}
+			const chunks = await chunkFile(filePath, content, this.config);
+			if (chunks.length === 0) continue;
+			const enrichedChunks = await enrichChunksFromFile(chunks, content);
+			const texts = enrichedChunks.map((c) => c.enrichedContent);
+			const embeddings = await this.ollamaClient.embedBatch(texts);
+			const embeddedChunks = enrichedChunks.map((chunk, i) => ({
+				id: chunk.id,
+				content: chunk.content,
+				filePath: chunk.filePath,
+				language: chunk.language,
+				startLine: chunk.startLine,
+				endLine: chunk.endLine,
+				symbolName: chunk.symbolName,
+				symbolType: chunk.symbolType,
+				vector: embeddings[i] ?? []
+			}));
+			await this.vectorStore.addChunks(embeddedChunks);
+			indexed++;
+		} catch (err) {
+			const error = err instanceof Error ? err : new Error(String(err));
+			logger.debug(`Error indexing ${filePath}: ${error.message}`);
+		}
+		this.saveHashCache();
+		logger.info(`Full index: ${String(indexed)} indexed, ${String(skipped)} skipped`);
+	}
+	/**
+	* Start watching for file changes
+	*/
+	async start() {
+		const health = await this.ollamaClient.healthCheck();
+		if (!health.ok) throw new Error(health.error ?? "Ollama is not available");
+		const needsFullIndex = !this.vectorStore.exists();
+		await this.vectorStore.connect();
+		if (needsFullIndex) await this.fullIndex();
+		this.watcher = watch(this.directory, {
+			ignored: (filePath) => {
+				const relativePath = path.relative(this.directory, filePath).replace(/\\/g, "/");
+				if (!relativePath) return false;
+				if (relativePath.split("/").some((part) => part.startsWith("."))) return true;
+				return this.ig.ignores(relativePath);
+			},
+			persistent: true,
+			ignoreInitial: true,
+			awaitWriteFinish: {
+				stabilityThreshold: 500,
+				pollInterval: 100
+			}
+		});
+		this.watcher.on("add", (filePath) => {
+			if (shouldIndexFile(filePath)) this.scheduleChange("add", filePath);
+		});
+		this.watcher.on("change", (filePath) => {
+			if (shouldIndexFile(filePath)) this.scheduleChange("change", filePath);
+		});
+		this.watcher.on("unlink", (filePath) => {
+			if (shouldIndexFile(filePath)) this.scheduleChange("unlink", filePath);
+		});
+		this.watcher.on("ready", () => {
+			logger.info(`Watching: ${this.directory} (${String(this.debounceMs)}ms debounce)`);
+			this.onReady?.();
+		});
+		this.watcher.on("error", (err) => {
+			const error = err instanceof Error ? err : new Error(String(err));
+			logger.error(`Watcher error: ${error.message}`);
+			this.onError?.(error);
+		});
+	}
+	/**
+	* Stop watching and cleanup
+	*/
+	async stop() {
+		for (const pending of this.pendingChanges.values()) clearTimeout(pending.timer);
+		this.pendingChanges.clear();
+		this.saveHashCache();
+		if (this.watcher) {
+			await this.watcher.close();
+			this.watcher = null;
+		}
+		this.vectorStore.close();
+		logger.info("Watcher stopped");
+	}
+	/**
+	* Check if watcher is running
+	*/
+	isRunning() {
+		return this.watcher !== null;
+	}
+	/**
+	* Clear the hash cache
+	*/
+	clearCache() {
+		this.hashCache = {};
+		const cachePath = this.getHashCachePath();
+		if (fs.existsSync(cachePath)) fs.unlinkSync(cachePath);
+		logger.info("Hash cache cleared");
+	}
+	/**
+	* Get cache statistics
+	*/
+	getCacheStats() {
+		return {
+			cachedFiles: Object.keys(this.hashCache).length,
+			cacheSize: JSON.stringify(this.hashCache).length
+		};
+	}
+};
+/**
+* Create a new index watcher
+*/
+function createIndexWatcher(options) {
+	return new IndexWatcher(options);
+}
+
+//#endregion
+//#region src/core/embeddings/callgraph.ts
+/**
+* Call graph extraction and storage
+*
+* Extracts function call relationships from code using tree-sitter
+* to build a graph showing which functions call which.
+*
+* Features:
+* - Persistent caching in .src-index/call-graph.json
+* - Hash-based invalidation for changed files
+*/
+/**
+* Compute SHA-256 hash of content
+*/
+function computeHash$1(content) {
+	return crypto.createHash("sha256").update(content).digest("hex").slice(0, 16);
+}
+/**
+* Get call graph cache path for a directory
+*/
+function getCachePath(directory) {
+	return path.join(directory, ".src-index", "call-graph.json");
+}
+/**
+* Save call graph to persistent cache
+*/
+function saveCallGraphCache(directory, graph, fileHashes) {
+	try {
+		const cachePath = getCachePath(directory);
+		const cacheDir = path.dirname(cachePath);
+		if (!fs.existsSync(cacheDir)) fs.mkdirSync(cacheDir, { recursive: true });
+		const serialized = {
+			nodes: Object.fromEntries(graph.nodes),
+			files: graph.files,
+			edgeCount: graph.edgeCount,
+			fileHashes,
+			timestamp: Date.now()
+		};
+		fs.writeFileSync(cachePath, JSON.stringify(serialized), "utf-8");
+		logger.debug(`Call graph cache saved: ${String(graph.nodes.size)} nodes`);
+	} catch {
+		logger.debug("Call graph cache save skipped: directory not writable");
+	}
+}
+/**
+* Load call graph from persistent cache if valid
+*/
+function loadCallGraphCache(directory, currentHashes) {
+	const cachePath = getCachePath(directory);
+	if (!fs.existsSync(cachePath)) return null;
+	try {
+		const content = fs.readFileSync(cachePath, "utf-8");
+		const cached = JSON.parse(content);
+		const cachedFiles = new Set(Object.keys(cached.fileHashes));
+		const currentFiles = new Set(Object.keys(currentHashes));
+		if (cachedFiles.size !== currentFiles.size) {
+			logger.debug("Call graph cache invalid: file count changed");
+			return null;
+		}
+		for (const [filePath, hash] of Object.entries(currentHashes)) if (cached.fileHashes[filePath] !== hash) {
+			logger.debug(`Call graph cache invalid: ${filePath} changed`);
+			return null;
+		}
+		const nodes = new Map(Object.entries(cached.nodes));
+		logger.debug(`Call graph cache loaded: ${String(nodes.size)} nodes`);
+		return {
+			nodes,
+			files: cached.files,
+			edgeCount: cached.edgeCount
+		};
+	} catch (error) {
+		logger.debug(`Failed to load call graph cache: ${error instanceof Error ? error.message : String(error)}`);
+		return null;
+	}
+}
+const callGraphCache = /* @__PURE__ */ new Map();
+/**
+* Clear the call graph cache
+*/
+function clearCallGraphCache() {
+	callGraphCache.clear();
+}
+registerCache("embeddings:callGraphCache", clearCallGraphCache);
+/**
+* Extract function calls from a tree-sitter node
+*/
+function extractCallsFromTree(tree, languageInstance, language) {
+	const callsBySymbol = /* @__PURE__ */ new Map();
+	const pattern = {
+		typescript: `
+      (call_expression
+        function: [(identifier) @callee
+                   (member_expression property: (property_identifier) @callee)]
+        arguments: (arguments) @args)
+    `,
+		javascript: `
+      (call_expression
+        function: [(identifier) @callee
+                   (member_expression property: (property_identifier) @callee)]
+        arguments: (arguments) @args)
+    `,
+		python: `
+      (call
+        function: [(identifier) @callee
+                   (attribute attribute: (identifier) @callee)]
+        arguments: (argument_list) @args)
+    `,
+		go: `
+      (call_expression
+        function: [(identifier) @callee
+                   (selector_expression field: (field_identifier) @callee)]
+        arguments: (argument_list) @args)
+    `
+	}[language];
+	if (!pattern) return callsBySymbol;
+	try {
+		const matches = new Query(languageInstance, pattern).matches(tree.rootNode);
+		const callCaptures = [];
+		for (const match of matches) for (const capture of match.captures) if (capture.name === "callee") callCaptures.push({
+			callee: capture.node.text,
+			position: {
+				line: capture.node.startPosition.row + 1,
+				column: capture.node.startPosition.column,
+				offset: capture.node.startIndex
+			}
+		});
+		if (callCaptures.length > 0) callsBySymbol.set("__global__", callCaptures.map((c) => ({
+			callee: c.callee,
+			position: c.position
+		})));
+	} catch (error) {
+		logger.debug(`Failed to extract calls for ${language}: ${error instanceof Error ? error.message : String(error)}`);
+	}
+	return callsBySymbol;
+}
+/**
+* Associate calls with their containing symbols
+*/
+function associateCallsWithSymbols(symbols, allCalls) {
+	const callsBySymbol = /* @__PURE__ */ new Map();
+	const sortedSymbols = [...symbols].filter((s) => s.type === "function" || s.type === "method").sort((a, b) => a.start.offset - b.start.offset);
+	for (const call of allCalls) {
+		let containingSymbol = null;
+		for (const symbol of sortedSymbols) if (call.position.offset >= symbol.start.offset && call.position.offset <= symbol.end.offset) containingSymbol = symbol;
+		else if (call.position.offset < symbol.start.offset) break;
+		const symbolName = containingSymbol?.name ?? "__global__";
+		const existing = callsBySymbol.get(symbolName) ?? [];
+		existing.push(call);
+		callsBySymbol.set(symbolName, existing);
+	}
+	return callsBySymbol;
+}
+/**
+* Analyze a file and extract call graph data
+*/
+async function analyzeFileForCallGraph(filePath, content) {
+	const cached = callGraphCache.get(filePath);
+	if (cached) return cached;
+	try {
+		const parseResult = await parseCode(content, { filePath });
+		const { symbols } = extractSymbols(parseResult.tree, parseResult.languageInstance, parseResult.language);
+		const data = {
+			symbols,
+			calls: associateCallsWithSymbols(symbols, extractCallsFromTree(parseResult.tree, parseResult.languageInstance, parseResult.language).get("__global__") ?? [])
+		};
+		callGraphCache.set(filePath, data);
+		return data;
+	} catch (error) {
+		logger.debug(`Failed to analyze ${filePath} for call graph: ${error instanceof Error ? error.message : String(error)}`);
+		return null;
+	}
+}
+/**
+* Build a call graph from multiple files
+*
+* Uses persistent caching with hash-based invalidation for performance.
+*/
+async function buildCallGraph(files) {
+	if (files.length === 0) return {
+		nodes: /* @__PURE__ */ new Map(),
+		files: [],
+		edgeCount: 0
+	};
+	const fileHashes = {};
+	for (const file of files) fileHashes[file.path] = computeHash$1(file.content);
+	const baseDir = findCommonDirectory(files.map((f) => f.path));
+	const cached = loadCallGraphCache(baseDir, fileHashes);
+	if (cached) return cached;
+	const nodes = /* @__PURE__ */ new Map();
+	const filePaths = [];
+	let edgeCount = 0;
+	for (const file of files) {
+		filePaths.push(file.path);
+		const data = await analyzeFileForCallGraph(file.path, file.content);
+		if (!data) continue;
+		for (const symbol of data.symbols) if (symbol.type === "function" || symbol.type === "method") {
+			const qualifiedName = `${file.path}:${symbol.name}`;
+			nodes.set(qualifiedName, {
+				name: symbol.name,
+				qualifiedName,
+				filePath: file.path,
+				type: symbol.type,
+				start: symbol.start,
+				end: symbol.end,
+				calls: [],
+				calledBy: []
+			});
+		}
+	}
+	for (const file of files) {
+		const data = callGraphCache.get(file.path);
+		if (!data) continue;
+		for (const [symbolName, calls] of data.calls) {
+			const callerKey = `${file.path}:${symbolName}`;
+			const callerNode = nodes.get(callerKey);
+			if (!callerNode && symbolName !== "__global__") continue;
+			for (const call of calls) for (const [nodeKey, node] of nodes) if (node.name === call.callee) {
+				if (callerNode) callerNode.calls.push(nodeKey);
+				node.calledBy.push(callerKey);
+				edgeCount++;
+			}
+		}
+	}
+	const graph = {
+		nodes,
+		files: filePaths,
+		edgeCount
+	};
+	saveCallGraphCache(baseDir, graph, fileHashes);
+	return graph;
+}
+/**
+* Find common directory from a list of file paths
+*/
+function findCommonDirectory(paths) {
+	if (paths.length === 0) return ".";
+	const firstPathStr = paths[0];
+	if (!firstPathStr) return ".";
+	if (paths.length === 1) return path.dirname(firstPathStr);
+	const segments = paths.map((p) => path.normalize(p).split(path.sep));
+	const firstPath = segments[0];
+	if (!firstPath) return ".";
+	let commonLength = 0;
+	for (let i = 0; i < firstPath.length; i++) {
+		const segment = firstPath[i];
+		if (segment && segments.every((s) => s[i] === segment)) commonLength = i + 1;
+		else break;
+	}
+	const commonDir = firstPath.slice(0, commonLength).join(path.sep);
+	if (commonDir && fs.existsSync(commonDir) && fs.statSync(commonDir).isFile()) return path.dirname(commonDir);
+	return commonDir || ".";
+}
+/**
+* Get callers and callees for a specific function
+*/
+function getCallContext(graph, filePath, functionName) {
+	const qualifiedName = `${filePath}:${functionName}`;
+	const node = graph.nodes.get(qualifiedName);
+	if (!node) return null;
+	const callers = [];
+	const callees = [];
+	for (const callerKey of node.calledBy) {
+		const caller = graph.nodes.get(callerKey);
+		if (caller) callers.push(caller);
+	}
+	for (const calleeKey of node.calls) {
+		const callee = graph.nodes.get(calleeKey);
+		if (callee) callees.push(callee);
+	}
+	return {
+		callers,
+		callees
+	};
+}
+
+//#endregion
+//#region src/features/index-codebase/index.ts
+/**
+* Index Codebase Feature
+*
+* Indexes a directory by:
+* 1. Scanning for supported files
+* 2. Chunking each file
+* 3. Generating embeddings via Ollama
+* 4. Storing in LanceDB
+*/
+/** Default concurrency for parallel file processing */
+const DEFAULT_CONCURRENCY = 4;
+/**
+* Process items in parallel with concurrency limit using worker pool pattern
+*/
+async function parallelMap(items, processor, concurrency) {
+	const results = new Array(items.length);
+	let currentIndex = 0;
+	const worker = async () => {
+		while (currentIndex < items.length) {
+			const index = currentIndex++;
+			const item = items[index];
+			if (item !== void 0) results[index] = await processor(item);
+		}
+	};
+	const workers = Array.from({ length: Math.min(concurrency, items.length) }, async () => worker());
+	await Promise.all(workers);
+	return results.filter((r) => r !== void 0);
+}
+const indexCodebaseSchema = z.object({
+	directory: z.string().optional().default(".").describe("Path to the directory to index (defaults to current directory)"),
+	force: z.boolean().optional().default(false).describe("Force re-indexing even if index exists"),
+	exclude: z.array(z.string()).optional().default([]).describe("Additional glob patterns to exclude"),
+	concurrency: z.number().int().positive().optional().default(DEFAULT_CONCURRENCY).describe("Number of files to process in parallel (default: 4)")
+});
+/**
+* Create an ignore instance with gitignore patterns and additional exclusions
+*/
+function createIgnoreFilter$2(baseDir, additionalExclusions) {
+	const ig = ignore();
+	const gitignorePath = path.join(baseDir, ".gitignore");
+	if (fs.existsSync(gitignorePath)) try {
+		const content = fs.readFileSync(gitignorePath, "utf-8");
+		ig.add(content);
+	} catch {}
+	if (additionalExclusions.length > 0) ig.add(additionalExclusions);
+	return ig;
+}
+/**
+* Check if a name starts with a dot (hidden file/folder)
+*/
+function isHidden$2(name) {
+	return name.startsWith(".");
+}
+/**
+* Recursively collect files from a directory
+*/
+function collectFiles$2(dir, ig, baseDir) {
+	const files = [];
+	const entries = fs.readdirSync(dir, { withFileTypes: true });
+	for (const entry of entries) {
+		if (isHidden$2(entry.name)) continue;
+		const fullPath = path.join(dir, entry.name);
+		const relativePath = path.relative(baseDir, fullPath).replace(/\\/g, "/");
+		if (ig.ignores(relativePath)) continue;
+		if (entry.isDirectory()) files.push(...collectFiles$2(fullPath, ig, baseDir));
+		else if (entry.isFile() && shouldIndexFile(entry.name)) files.push(fullPath);
+	}
+	return files;
+}
+/**
+* Execute the index_codebase feature
+*/
+async function execute$3(input) {
+	const { directory, force, exclude, concurrency } = input;
+	if (!fs.existsSync(directory)) return {
+		success: false,
+		error: `Directory not found: ${directory}`
+	};
+	const absoluteDir = path.resolve(directory);
+	const ollamaClient = createOllamaClient(EMBEDDING_CONFIG);
+	const vectorStore = createVectorStore(absoluteDir, EMBEDDING_CONFIG);
+	const health = await ollamaClient.healthCheck();
+	if (!health.ok) return {
+		success: false,
+		error: health.error ?? "Ollama is not available"
+	};
+	if (vectorStore.exists() && !force) return {
+		success: false,
+		error: "Index already exists. Use force=true to re-index or search_code to query."
+	};
+	const result = {
+		directory: absoluteDir,
+		filesIndexed: 0,
+		chunksCreated: 0,
+		languages: {},
+		errors: []
+	};
+	try {
+		await vectorStore.connect();
+		if (force && vectorStore.exists()) await vectorStore.clear();
+		const files = collectFiles$2(absoluteDir, createIgnoreFilter$2(absoluteDir, exclude), absoluteDir);
+		if (files.length === 0) return {
+			success: true,
+			message: "No indexable files found in directory",
+			data: result
+		};
+		const pathAliases = readPathAliasesCached(absoluteDir);
+		const aliasCount = Object.keys(pathAliases).length;
+		const enrichmentOptions = {
+			projectRoot: absoluteDir,
+			pathAliases,
+			includeCrossFileContext: true
+		};
+		logger.debug(`Indexing ${String(files.length)} files with concurrency=${String(concurrency)} (projectRoot: ${absoluteDir}, ${String(aliasCount)} path aliases)`);
+		const processFile = async (filePath) => {
+			try {
+				const content = fs.readFileSync(filePath, "utf-8");
+				return { chunks: await enrichChunksFromFile(await chunkFile(filePath, content, EMBEDDING_CONFIG), content, enrichmentOptions) };
+			} catch (err) {
+				return {
+					chunks: [],
+					error: `Error processing ${filePath}: ${err instanceof Error ? err.message : String(err)}`
+				};
+			}
+		};
+		const fileResults = await parallelMap(files, processFile, concurrency);
+		const allEnrichedChunks = [];
+		for (const fileResult of fileResults) if (fileResult.error) result.errors.push(fileResult.error);
+		else {
+			allEnrichedChunks.push(...fileResult.chunks);
+			result.filesIndexed++;
+			for (const chunk of fileResult.chunks) result.languages[chunk.language] = (result.languages[chunk.language] ?? 0) + 1;
+		}
+		const { batchSize } = EMBEDDING_CONFIG;
+		const embeddedChunks = [];
+		for (let i = 0; i < allEnrichedChunks.length; i += batchSize) {
+			const batch = allEnrichedChunks.slice(i, i + batchSize);
+			const texts = batch.map((c) => c.enrichedContent);
+			try {
+				const embeddings = await ollamaClient.embedBatch(texts);
+				for (let j = 0; j < batch.length; j++) {
+					const chunk = batch[j];
+					const vector = embeddings[j];
+					if (chunk && vector) embeddedChunks.push({
+						id: chunk.id,
+						content: chunk.content,
+						filePath: chunk.filePath,
+						language: chunk.language,
+						startLine: chunk.startLine,
+						endLine: chunk.endLine,
+						symbolName: chunk.symbolName,
+						symbolType: chunk.symbolType,
+						vector
+					});
+				}
+			} catch (err) {
+				const errorMsg = err instanceof Error ? err.message : String(err);
+				result.errors.push(`Embedding batch error: ${errorMsg}`);
+			}
+		}
+		if (embeddedChunks.length > 0) {
+			await vectorStore.addChunks(embeddedChunks);
+			result.chunksCreated = embeddedChunks.length;
+		}
+		vectorStore.close();
+		return {
+			success: true,
+			message: result.errors.length > 0 ? `Indexed ${String(result.filesIndexed)} files (${String(result.chunksCreated)} chunks) with ${String(result.errors.length)} errors` : `Successfully indexed ${String(result.filesIndexed)} files (${String(result.chunksCreated)} chunks)`,
+			data: result
+		};
+	} catch (err) {
+		vectorStore.close();
+		return {
+			success: false,
+			error: `Indexing failed: ${err instanceof Error ? err.message : String(err)}`,
+			data: result
+		};
+	}
+}
+const indexCodebaseFeature = {
+	name: "index_codebase",
+	description: "Index a codebase for semantic code search. USE THIS FIRST before search_code. Required once per project - creates vector embeddings for 50+ languages. After initial indexing, use update_index for incremental updates.",
+	schema: indexCodebaseSchema,
+	execute: execute$3
+};
+
+//#endregion
+//#region src/features/search-code/index.ts
+/**
+* Search Code Feature
+*
+* Performs hybrid search on indexed codebase combining:
+* 1. Vector similarity search (semantic embeddings via Ollama)
+* 2. Full-text search (BM25 keyword matching)
+* 3. RRF (Reciprocal Rank Fusion) to combine results
+*
+* Supports three search modes:
+* - 'hybrid' (default): Best of both vector and keyword search
+* - 'vector': Semantic search only
+* - 'fts': Keyword search only
+*
+* Optional features:
+* - LLM re-ranking for improved relevance
+* - Call context to show callers/callees for each result
+*/
+const searchCodeSchema = z.object({
+	query: z.string().min(1).describe("Natural language search query"),
+	directory: z.string().optional().default(".").describe("Path to the indexed directory (defaults to current directory)"),
+	limit: z.number().int().positive().optional().default(10).describe("Maximum number of results to return"),
+	threshold: z.number().min(0).max(2).optional().describe("Maximum distance threshold for results (lower = more similar)"),
+	mode: z.enum([
+		"vector",
+		"fts",
+		"hybrid"
+	]).optional().default("hybrid").describe("Search mode: 'vector' (semantic only), 'fts' (keyword only), 'hybrid' (combined with RRF fusion)"),
+	includeCallContext: z.boolean().optional().default(true).describe("Include caller/callee information for each result (uses cached call graph)")
+});
+/**
+* Create gitignore filter
+*/
+function createIgnoreFilter$1(directory) {
+	const ig = ignore();
+	ig.add([
+		"node_modules",
+		".git",
+		"dist",
+		"build",
+		".src-index"
+	]);
+	const gitignorePath = path.join(directory, ".gitignore");
+	if (fs.existsSync(gitignorePath)) {
+		const content = fs.readFileSync(gitignorePath, "utf-8");
+		ig.add(content);
+	}
+	return ig;
+}
+/**
+* Check if hidden file/folder
+*/
+function isHidden$1(name) {
+	return name.startsWith(".");
+}
+/**
+* Recursively collect files for call graph
+*/
+function collectFiles$1(dir, ig, baseDir) {
+	const files = [];
+	const entries = fs.readdirSync(dir, { withFileTypes: true });
+	for (const entry of entries) {
+		if (isHidden$1(entry.name)) continue;
+		const fullPath = path.join(dir, entry.name);
+		const relativePath = path.relative(baseDir, fullPath).replace(/\\/g, "/");
+		if (ig.ignores(relativePath)) continue;
+		if (entry.isDirectory()) files.push(...collectFiles$1(fullPath, ig, baseDir));
+		else if (entry.isFile() && shouldIndexFile(entry.name)) files.push(fullPath);
+	}
+	return files;
+}
+/**
+* Format search results for output
+*/
+function formatResults(results, baseDir) {
+	return results.map((r) => ({
+		filePath: path.relative(baseDir, r.chunk.filePath),
+		language: r.chunk.language,
+		startLine: r.chunk.startLine,
+		endLine: r.chunk.endLine,
+		content: r.chunk.content,
+		score: r.score,
+		symbolName: r.chunk.symbolName,
+		symbolType: r.chunk.symbolType
+	}));
+}
+/**
+* Execute the search_code feature
+*/
+async function execute$2(input) {
+	const { query, directory, limit, threshold, mode, includeCallContext } = input;
+	if (!fs.existsSync(directory)) return {
+		success: false,
+		error: `Directory not found: ${directory}`
+	};
+	const absoluteDir = path.resolve(directory);
+	const ollamaClient = createOllamaClient(EMBEDDING_CONFIG);
+	const vectorStore = createVectorStore(absoluteDir, EMBEDDING_CONFIG);
+	if (!vectorStore.exists()) return {
+		success: false,
+		error: `No index found for directory. Run index_codebase first: ${absoluteDir}`
+	};
+	try {
+		const health = await ollamaClient.healthCheck();
+		if (!health.ok) return {
+			success: false,
+			error: health.error ?? "Ollama is not available"
+		};
+		await vectorStore.connect();
+		const queryVector = await ollamaClient.embed(query);
+		let results = await vectorStore.searchHybrid(queryVector, query, limit, { mode });
+		if (threshold !== void 0 && mode === "vector") results = results.filter((r) => r.score <= threshold);
+		vectorStore.close();
+		let formattedResults = formatResults(results, absoluteDir);
+		if (includeCallContext && formattedResults.length > 0) {
+			const callGraph = await buildCallGraph(collectFiles$1(absoluteDir, createIgnoreFilter$1(absoluteDir), absoluteDir).map((f) => ({
+				path: f,
+				content: fs.readFileSync(f, "utf-8")
+			})));
+			formattedResults = formattedResults.map((result) => {
+				if (!result.symbolName) return result;
+				const context = getCallContext(callGraph, path.join(absoluteDir, result.filePath), result.symbolName);
+				if (context) return {
+					...result,
+					callContext: {
+						callers: context.callers.map((c) => c.name),
+						callees: context.callees.map((c) => c.name)
+					}
+				};
+				return result;
+			});
+		}
+		const output = {
+			query,
+			directory: absoluteDir,
+			resultsCount: formattedResults.length,
+			results: formattedResults
+		};
+		if (formattedResults.length === 0) return {
+			success: true,
+			message: "No matching code found",
+			data: output
+		};
+		const resultLines = formattedResults.map((r, i) => {
+			const location = `${r.filePath}:${String(r.startLine)}-${String(r.endLine)}`;
+			const symbol = r.symbolName ? ` (${r.symbolType ?? "symbol"}: ${r.symbolName})` : "";
+			const preview = r.content.slice(0, 100).replace(/\n/g, " ");
+			let callInfo = "";
+			if (r.callContext) {
+				const callers = r.callContext.callers.length > 0 ? `Called by: ${r.callContext.callers.slice(0, 3).join(", ")}${r.callContext.callers.length > 3 ? "..." : ""}` : "";
+				const callees = r.callContext.callees.length > 0 ? `Calls: ${r.callContext.callees.slice(0, 3).join(", ")}${r.callContext.callees.length > 3 ? "..." : ""}` : "";
+				if (callers || callees) callInfo = `\n   ${[callers, callees].filter(Boolean).join(" | ")}`;
+			}
+			return `${String(i + 1)}. [${r.language}] ${location}${symbol}\n   ${preview}...${callInfo}`;
+		});
+		return {
+			success: true,
+			message: `Found ${String(formattedResults.length)} results for "${query}":\n\n${resultLines.join("\n\n")}`,
+			data: output
+		};
+	} catch (err) {
+		vectorStore.close();
+		return {
+			success: false,
+			error: `Search failed: ${err instanceof Error ? err.message : String(err)}`
+		};
+	}
+}
+const searchCodeFeature = {
+	name: "search_code",
+	description: "Search code semantically using natural language queries. USE THIS to find code by concept/meaning (e.g., 'authentication logic', 'error handling'). Requires index_codebase first. Returns relevant code chunks with file locations, function names, and call relationships (who calls what).",
+	schema: searchCodeSchema,
+	execute: execute$2
+};
+
+//#endregion
+//#region src/features/get-index-status/index.ts
+/**
+* Get Index Status Feature
+*
+* Returns information about the embedding index for a directory:
+* - Whether an index exists
+* - Total chunks and files indexed
+* - Language breakdown
+*/
+const getIndexStatusSchema = z.object({ directory: z.string().optional().default(".").describe("Path to the directory to check (defaults to current directory)") });
+/**
+* Execute the get_index_status feature
+*/
+async function execute$1(input) {
+	const { directory } = input;
+	if (!fs.existsSync(directory)) return {
+		success: false,
+		error: `Directory not found: ${directory}`
+	};
+	const absoluteDir = path.resolve(directory);
+	const indexPath = getIndexPath(absoluteDir);
+	if (!fs.existsSync(indexPath)) {
+		const status = {
+			directory: absoluteDir,
+			indexPath,
+			exists: false,
+			totalChunks: 0,
+			totalFiles: 0,
+			languages: {}
+		};
+		return {
+			success: true,
+			message: `No index found for ${absoluteDir}. Run index_codebase to create one.`,
+			data: status
+		};
+	}
+	try {
+		const vectorStore = createVectorStore(absoluteDir, EMBEDDING_CONFIG);
+		await vectorStore.connect();
+		const status = await vectorStore.getStatus(absoluteDir);
+		vectorStore.close();
+		const languageLines = Object.entries(status.languages).sort(([, a], [, b]) => b - a).map(([lang, count]) => `  - ${lang}: ${String(count)} chunks`);
+		return {
+			success: true,
+			message: [
+				`Index Status for ${absoluteDir}`,
+				``,
+				`Index Path: ${status.indexPath}`,
+				`Total Files: ${String(status.totalFiles)}`,
+				`Total Chunks: ${String(status.totalChunks)}`,
+				``,
+				`Languages:`,
+				...languageLines
+			].join("\n"),
+			data: status
+		};
+	} catch (err) {
+		return {
+			success: false,
+			error: `Failed to read index status: ${err instanceof Error ? err.message : String(err)}`
+		};
+	}
+}
+const getIndexStatusFeature = {
+	name: "get_index_status",
+	description: "Check if a codebase is indexed and ready for search. USE THIS to verify index exists before searching. Returns file count, chunk count, and indexed languages.",
+	schema: getIndexStatusSchema,
+	execute: execute$1
+};
+
+//#endregion
+//#region src/features/get-call-graph/index.ts
+/**
+* Get Call Graph Feature
+*
+* Analyzes function call relationships in a codebase.
+* Can either:
+* 1. Build a full call graph for a directory
+* 2. Query callers/callees for a specific function
+*/
+const getCallGraphSchema = z.object({
+	directory: z.string().optional().default(".").describe("Path to the directory to analyze"),
+	functionName: z.string().optional().describe("Optional: specific function name to query callers/callees for"),
+	filePath: z.string().optional().describe("Optional: file path to narrow down function search (used with functionName)"),
+	maxDepth: z.number().int().positive().optional().default(2).describe("Maximum depth for call chain traversal (default: 2)"),
+	exclude: z.array(z.string()).optional().default([]).describe("Glob patterns to exclude from analysis")
+});
+
+//#endregion
+//#region src/features/update-index/index.ts
+/**
+* Update Index Feature
+*
+* Incrementally updates the codebase index by:
+* 1. Detecting files that have changed since last indexing
+* 2. Re-indexing only the changed files
+* 3. Removing deleted files from the index
+*
+* Uses SHA-256 hash comparison to detect real content changes.
+*/
+/** Cache file name for storing hashes */
+const HASH_CACHE_FILE = ".src-index-hashes.json";
+const updateIndexSchema = z.object({
+	directory: z.string().optional().default(".").describe("Path to the indexed directory"),
+	dryRun: z.boolean().optional().default(false).describe("Only report changes without updating the index"),
+	force: z.boolean().optional().default(false).describe("Force re-index of all files (ignore hash cache)")
+});
+/**
+* Compute SHA-256 hash of content
+*/
+function computeHash(content) {
+	return crypto.createHash("sha256").update(content, "utf8").digest("hex");
+}
+/**
+* Get hash cache file path
+*/
+function getHashCachePath(directory) {
+	return path.join(directory, ".src-index", HASH_CACHE_FILE);
+}
+/**
+* Load hash cache from disk
+*/
+function loadHashCache(directory) {
+	const cachePath = getHashCachePath(directory);
+	if (fs.existsSync(cachePath)) try {
+		const content = fs.readFileSync(cachePath, "utf-8");
+		return JSON.parse(content);
+	} catch {
+		return {};
+	}
+	return {};
+}
+/**
+* Save hash cache to disk
+*/
+function saveHashCache(directory, cache) {
+	const cachePath = getHashCachePath(directory);
+	const cacheDir = path.dirname(cachePath);
+	if (!fs.existsSync(cacheDir)) fs.mkdirSync(cacheDir, { recursive: true });
+	fs.writeFileSync(cachePath, JSON.stringify(cache, null, 2));
+}
+/**
+* Create gitignore filter
+*/
+function createIgnoreFilter(directory) {
+	const ig = ignore();
+	ig.add([
+		"node_modules",
+		".git",
+		"dist",
+		"build",
+		".src-index"
+	]);
+	const gitignorePath = path.join(directory, ".gitignore");
+	if (fs.existsSync(gitignorePath)) {
+		const content = fs.readFileSync(gitignorePath, "utf-8");
+		ig.add(content);
+	}
+	return ig;
+}
+/**
+* Check if a name starts with a dot (hidden)
+*/
+function isHidden(name) {
+	return name.startsWith(".");
+}
+/**
+* Recursively collect files
+*/
+function collectFiles(dir, ig, baseDir) {
+	const files = [];
+	const entries = fs.readdirSync(dir, { withFileTypes: true });
+	for (const entry of entries) {
+		if (isHidden(entry.name)) continue;
+		const fullPath = path.join(dir, entry.name);
+		const relativePath = path.relative(baseDir, fullPath).replace(/\\/g, "/");
+		if (ig.ignores(relativePath)) continue;
+		if (entry.isDirectory()) files.push(...collectFiles(fullPath, ig, baseDir));
+		else if (entry.isFile() && shouldIndexFile(entry.name)) files.push(fullPath);
+	}
+	return files;
+}
+/**
+* Execute the update_index feature
+*/
+async function execute(input) {
+	const { directory, dryRun, force } = input;
+	if (!fs.existsSync(directory)) return {
+		success: false,
+		error: `Directory not found: ${directory}`
+	};
+	const absoluteDir = path.resolve(directory);
+	const ollamaClient = createOllamaClient(EMBEDDING_CONFIG);
+	const vectorStore = createVectorStore(absoluteDir, EMBEDDING_CONFIG);
+	if (!vectorStore.exists()) return {
+		success: false,
+		error: `No index found for directory. Run index_codebase first: ${absoluteDir}`
+	};
+	const result = {
+		directory: absoluteDir,
+		dryRun,
+		added: [],
+		modified: [],
+		removed: [],
+		unchanged: 0,
+		errors: []
+	};
+	try {
+		if (!dryRun) {
+			const health = await ollamaClient.healthCheck();
+			if (!health.ok) return {
+				success: false,
+				error: health.error ?? "Ollama is not available"
+			};
+		}
+		await vectorStore.connect();
+		const hashCache = force ? {} : loadHashCache(absoluteDir);
+		const newHashCache = {};
+		const ig = createIgnoreFilter(absoluteDir);
+		const currentFiles = new Set(collectFiles(absoluteDir, ig, absoluteDir));
+		const indexedFiles = new Set(await vectorStore.getIndexedFiles());
+		const filesToProcess = [];
+		for (const filePath of currentFiles) {
+			const hash = computeHash(fs.readFileSync(filePath, "utf-8"));
+			newHashCache[filePath] = hash;
+			if (!indexedFiles.has(filePath)) {
+				result.added.push(path.relative(absoluteDir, filePath));
+				filesToProcess.push({
+					path: filePath,
+					type: "add"
+				});
+			} else if (hashCache[filePath] !== hash) {
+				result.modified.push(path.relative(absoluteDir, filePath));
+				filesToProcess.push({
+					path: filePath,
+					type: "modify"
+				});
+			} else result.unchanged++;
+		}
+		for (const filePath of indexedFiles) if (!currentFiles.has(filePath)) result.removed.push(path.relative(absoluteDir, filePath));
+		if (dryRun) {
+			vectorStore.close();
+			return {
+				success: true,
+				message: buildDryRunMessage(result),
+				data: result
+			};
+		}
+		const enrichmentOptions = {
+			projectRoot: absoluteDir,
+			pathAliases: readPathAliasesCached(absoluteDir),
+			includeCrossFileContext: true
+		};
+		const embeddedChunks = [];
+		for (const { path: filePath, type } of filesToProcess) try {
+			if (type === "modify") await vectorStore.deleteByFilePath(filePath);
+			const content = fs.readFileSync(filePath, "utf-8");
+			const chunks = await chunkFile(filePath, content, EMBEDDING_CONFIG);
+			if (chunks.length === 0) continue;
+			const enrichedChunks = await enrichChunksFromFile(chunks, content, enrichmentOptions);
+			const texts = enrichedChunks.map((c) => c.enrichedContent);
+			const embeddings = await ollamaClient.embedBatch(texts);
+			for (let i = 0; i < enrichedChunks.length; i++) {
+				const chunk = enrichedChunks[i];
+				const vector = embeddings[i];
+				if (chunk && vector) embeddedChunks.push({
+					id: chunk.id,
+					content: chunk.content,
+					filePath: chunk.filePath,
+					language: chunk.language,
+					startLine: chunk.startLine,
+					endLine: chunk.endLine,
+					symbolName: chunk.symbolName,
+					symbolType: chunk.symbolType,
+					vector
+				});
+			}
+		} catch (err) {
+			const errorMsg = err instanceof Error ? err.message : String(err);
+			result.errors.push(`Error processing ${filePath}: ${errorMsg}`);
+		}
+		if (embeddedChunks.length > 0) await vectorStore.addChunks(embeddedChunks);
+		for (const relativePath of result.removed) {
+			const filePath = path.join(absoluteDir, relativePath);
+			await vectorStore.deleteByFilePath(filePath);
+		}
+		saveHashCache(absoluteDir, newHashCache);
+		vectorStore.close();
+		return {
+			success: true,
+			message: buildResultMessage(result),
+			data: result
+		};
+	} catch (err) {
+		vectorStore.close();
+		return {
+			success: false,
+			error: `Update failed: ${err instanceof Error ? err.message : String(err)}`
+		};
+	}
+}
+/**
+* Build message for dry run
+*/
+function buildDryRunMessage(result) {
+	const lines = ["Dry run - changes detected:"];
+	if (result.added.length > 0) {
+		lines.push(`\nFiles to add (${String(result.added.length)}):`);
+		for (const f of result.added.slice(0, 10)) lines.push(`  + ${f}`);
+		if (result.added.length > 10) lines.push(`  ... and ${String(result.added.length - 10)} more`);
+	}
+	if (result.modified.length > 0) {
+		lines.push(`\nFiles to update (${String(result.modified.length)}):`);
+		for (const f of result.modified.slice(0, 10)) lines.push(`  ~ ${f}`);
+		if (result.modified.length > 10) lines.push(`  ... and ${String(result.modified.length - 10)} more`);
+	}
+	if (result.removed.length > 0) {
+		lines.push(`\nFiles to remove (${String(result.removed.length)}):`);
+		for (const f of result.removed.slice(0, 10)) lines.push(`  - ${f}`);
+		if (result.removed.length > 10) lines.push(`  ... and ${String(result.removed.length - 10)} more`);
+	}
+	lines.push(`\nUnchanged: ${String(result.unchanged)} files`);
+	if (result.added.length === 0 && result.modified.length === 0 && result.removed.length === 0) return "Index is up to date - no changes detected.";
+	lines.push("\nRun without --dryRun to apply changes.");
+	return lines.join("\n");
+}
+/**
+* Build message for actual update
+*/
+function buildResultMessage(result) {
+	if (result.added.length + result.modified.length + result.removed.length === 0) return "Index is up to date - no changes needed.";
+	const lines = ["Index updated successfully:"];
+	if (result.added.length > 0) lines.push(`  Added: ${String(result.added.length)} files`);
+	if (result.modified.length > 0) lines.push(`  Modified: ${String(result.modified.length)} files`);
+	if (result.removed.length > 0) lines.push(`  Removed: ${String(result.removed.length)} files`);
+	lines.push(`  Unchanged: ${String(result.unchanged)} files`);
+	if (result.errors.length > 0) {
+		lines.push(`\nErrors (${String(result.errors.length)}):`);
+		for (const err of result.errors.slice(0, 5)) lines.push(`  - ${err}`);
+	}
+	return lines.join("\n");
+}
+const updateIndexFeature = {
+	name: "update_index",
+	description: "Refresh the search index after code changes. USE THIS instead of re-indexing - it's fast because it only processes changed files (SHA-256 hash detection). Use dryRun=true to preview changes first.",
+	schema: updateIndexSchema,
+	execute
+};
+
+//#endregion
+//#region src/features/parse-ast/index.ts
+const parseAstSchema = z.object({
+	file_path: z.string().optional().describe("Path to the file to parse (either file_path or content required)"),
+	content: z.string().optional().describe("Code content to parse directly (either file_path or content required)"),
+	language: z.string().optional().describe("Language name (auto-detected from file path if not provided)"),
+	max_depth: z.number().int().positive().optional().describe("Maximum depth of AST to return (default: unlimited)")
+}).refine((data) => data.file_path ?? data.content, { message: "Either file_path or content must be provided" });
+
+//#endregion
+//#region src/features/query-code/index.ts
+const presetValues = [
+	"functions",
+	"classes",
+	"imports",
+	"exports",
+	"comments",
+	"strings",
+	"variables",
+	"types"
+];
+const queryCodeSchema = z.object({
+	file_path: z.string().optional().describe("Path to the file to query (either file_path or content required)"),
+	content: z.string().optional().describe("Code content to query directly (either file_path or content required)"),
+	language: z.string().optional().describe("Language name (auto-detected from file path if not provided)"),
+	query: z.string().optional().describe("SCM query pattern (either query or preset required)"),
+	preset: z.enum(presetValues).optional().describe("Preset query name: functions, classes, imports, exports, comments, strings, variables, types"),
+	max_matches: z.number().int().positive().optional().describe("Maximum number of matches to return")
+}).refine((data) => data.file_path ?? data.content, { message: "Either file_path or content must be provided" }).refine((data) => data.query ?? data.preset, { message: "Either query or preset must be provided" });
+
+//#endregion
+//#region src/features/list-symbols/index.ts
+const symbolTypeValues = [
+	"function",
+	"class",
+	"variable",
+	"constant",
+	"interface",
+	"type",
+	"enum",
+	"method",
+	"property"
+];
+const listSymbolsSchema = z.object({
+	file_path: z.string().optional().describe("Path to the file to analyze (either file_path or content required)"),
+	content: z.string().optional().describe("Code content to analyze directly (either file_path or content required)"),
+	language: z.string().optional().describe("Language name (auto-detected from file path if not provided)"),
+	types: z.array(z.enum(symbolTypeValues)).optional().describe("Filter by symbol types: function, class, variable, constant, interface, type, enum, method, property")
+}).refine((data) => data.file_path ?? data.content, { message: "Either file_path or content must be provided" });
+
+//#endregion
+//#region src/core/fallback/index.ts
+let langchainConfig = null;
+function clearConfigCache() {
+	langchainConfig = null;
+}
+registerCache("fallback:config", clearConfigCache);
+
+//#endregion
+//#region src/core/unified/index.ts
+let configCache = null;
+let binaryExtensionsCache = null;
+let extensionToLanguageCache = null;
+let specialFilenamesCache = null;
+/** Clear caches (for testing) */
+function clearUnifiedCache() {
+	configCache = null;
+	binaryExtensionsCache = null;
+	extensionToLanguageCache = null;
+	specialFilenamesCache = null;
+}
+registerCache("unified:config", clearUnifiedCache);
+
+//#endregion
+//#region src/features/analyze-file/index.ts
+const analyzeFileSchema = z.object({
+	file_path: z.string().describe("Path to the file to analyze"),
+	include_ast: z.boolean().default(false).describe("Include full AST in response (default: false, can be verbose)"),
+	include_symbols: z.boolean().default(true).describe("Include extracted symbols (default: true)"),
+	include_imports: z.boolean().default(true).describe("Include import statements (default: true)"),
+	include_exports: z.boolean().default(true).describe("Include export statements (default: true)"),
+	ast_max_depth: z.number().int().positive().optional().describe("Maximum depth for AST if included"),
+	include_chunks: z.boolean().default(false).describe("Include text chunks for fallback parsing (default: false)")
+});
+
+//#endregion
+//#region src/features/index.ts
+const features = [
+	infoFeature,
+	indexCodebaseFeature,
+	searchCodeFeature,
+	getIndexStatusFeature,
+	updateIndexFeature
+];
+
+//#endregion
+//#region src/tools/adapter.ts
+function zodToMcpSchema(schema) {
+	if (schema instanceof z.ZodObject) return schema.shape;
+	return { input: schema };
+}
+function registerFeatureAsTool(server, feature) {
+	const mcpSchema = zodToMcpSchema(feature.schema);
+	server.tool(feature.name, feature.description, mcpSchema, async (params) => {
+		const result = feature.execute(params);
+		const formatResult = (res) => ({
+			content: [{
+				type: "text",
+				text: res.message ?? JSON.stringify(res.data, null, 2)
+			}],
+			isError: !res.success
+		});
+		if (result instanceof Promise) return await result.then(formatResult);
+		return formatResult(result);
+	});
+}
+
+//#endregion
+//#region src/tools/index.ts
+function registerTools(server) {
+	for (const feature of features) registerFeatureAsTool(server, feature);
+}
+
+//#endregion
+//#region src/resources/index.ts
+function registerResources(server) {
+	server.resource("server_info", "src://server/info", (uri) => {
+		const info = getServerInfo();
+		return { contents: [{
+			uri: uri.href,
+			mimeType: "application/json",
+			text: JSON.stringify(info, null, 2)
+		}] };
+	});
+}
+
+//#endregion
+//#region src/prompts/index.ts
+/**
+* Register MCP prompts
+*
+* Prompts are reusable templates that help AI assistants understand
+* how to use SRC effectively for code search and analysis.
+*/
+function registerPrompts(server) {
+	server.registerPrompt("src-overview", {
+		title: "SRC Overview",
+		description: "Learn about SRC capabilities and when to use it for code search and analysis"
+	}, () => ({ messages: [{
+		role: "user",
+		content: {
+			type: "text",
+			text: `# SRC (Structured Repo Context) - Overview
+
+## What is SRC?
+SRC is a semantic code search MCP server. It indexes codebases and provides intelligent search using:
+- **Vector embeddings** for semantic similarity (understands meaning, not just keywords)
+- **BM25 keyword search** for exact matches
+- **Hybrid search** combining both with RRF fusion
+- **Call graph analysis** showing function relationships
+
+## When to use SRC?
+
+**USE SRC when the user wants to:**
+- Find code by meaning/concept ("find authentication logic", "where is error handling")
+- Understand code relationships ("what calls this function", "what does this function call")
+- Search across a large codebase
+- Find similar code patterns
+- Explore unfamiliar code
+
+**DON'T USE SRC for:**
+- Reading a specific file (use file read tools instead)
+- Simple text search in a single file (use grep/search)
+- Non-code queries
+
+## Typical Workflow
+
+1. **Check status**: Use \`get_index_status\` to see if index exists
+2. **Index if needed**: Use \`index_codebase\` (only once per project)
+3. **Search**: Use \`search_code\` with natural language queries
+
+Note: When using \`serve\` mode, the server auto-indexes on startup and watches for file changes.
+
+## Supported Languages
+- **Full AST support (18)**: JavaScript, TypeScript, Python, Rust, Go, Java, C, C++, C#, Ruby, PHP, Kotlin, Scala, Swift, HTML, Svelte, OCaml
+- **Text splitting (16+)**: Markdown, LaTeX, Solidity, Haskell, Elixir, and more
+- **Generic (30+)**: Config files, shell scripts, SQL, and more
+
+## Tips
+- Use natural language queries: "authentication middleware" not "auth*"
+- The hybrid search mode (default) works best for most queries
+- Call context is included by default - shows who calls what`
+		}
+	}] }));
+	server.registerPrompt("code-search-workflow", {
+		title: "Code Search Workflow",
+		description: "Step-by-step guide for searching code with SRC"
+	}, () => ({ messages: [{
+		role: "user",
+		content: {
+			type: "text",
+			text: `# Code Search Workflow with SRC
+
+## Step 1: Check Index
+\`\`\`
+get_index_status()
+\`\`\`
+
+## Step 2: Index if Needed
+If no index exists:
+\`\`\`
+index_codebase()
+\`\`\`
+
+## Step 3: Search
+\`\`\`
+search_code(query: "your search query here")
+\`\`\`
+
+## search_code Arguments
+
+| Argument | Type | Default | Description |
+|----------|------|---------|-------------|
+| query | string | required | Natural language search query |
+| limit | number | 10 | Max results to return |
+| mode | "hybrid" / "vector" / "fts" | "hybrid" | Search mode |
+| includeCallContext | boolean | true | Include caller/callee info |
+| threshold | number | - | Distance threshold (vector mode only) |
+
+## Search Modes
+- **hybrid** (default): Vector + BM25 + RRF fusion - best overall
+- **vector**: Semantic similarity only - good for conceptual queries
+- **fts**: Keyword search only - good for exact identifiers
+
+## Examples
+\`\`\`
+// Find authentication code
+search_code(query: "user authentication and login")
+
+// More results
+search_code(query: "error handling", limit: 20)
+
+// Exact identifier search
+search_code(query: "UserAuthService", mode: "fts")
+
+// Without call context (faster)
+search_code(query: "database queries", includeCallContext: false)
+\`\`\``
+		}
+	}] }));
+	server.registerPrompt("search-tips", {
+		title: "Search Tips",
+		description: "Tips for writing effective code search queries"
+	}, () => ({ messages: [{
+		role: "user",
+		content: {
+			type: "text",
+			text: `# Effective Code Search Tips
+
+## Good Query Examples
+
+| Goal | Good Query | Why |
+|------|------------|-----|
+| Find auth code | "user authentication and login validation" | Describes the concept |
+| Find error handling | "error handling and exception catching" | Uses related terms |
+| Find API endpoints | "REST API route handlers" | Specifies the pattern |
+| Find database code | "database query and data persistence" | Covers the domain |
+| Find a function | "calculateTotalPrice function" | Includes the name |
+
+## Query Writing Tips
+
+1. **Be descriptive, not literal**
+   - Good: "user password validation and hashing"
+   - Bad: "validatePassword"
+
+2. **Include context**
+   - Good: "authentication middleware for Express routes"
+   - Bad: "auth middleware"
+
+3. **Use domain language**
+   - Good: "shopping cart checkout process"
+   - Bad: "cart function"
+
+4. **Combine concepts**
+   - Good: "file upload with size validation and error handling"
+   - Bad: "upload"
+
+## Search Mode Selection
+
+| Mode | Use When |
+|------|----------|
+| **hybrid** | Default choice, works for most queries |
+| **vector** | Conceptual searches like "code that handles retries" |
+| **fts** | Exact identifiers like "UserAuthService" |
+
+## Understanding Results
+
+Each result includes:
+- **content**: The matching code chunk
+- **filePath**: Source file location
+- **startLine/endLine**: Line numbers
+- **symbolName/Type**: Function or class name if detected
+- **score**: Relevance score (higher = better match)
+- **callers**: Functions that call this code
+- **callees**: Functions this code calls`
+		}
+	}] }));
+}
+
+//#endregion
+//#region src/server.ts
+function createServer() {
+	const server = new McpServer({
+		name: config.name,
+		version: config.version
+	});
+	registerTools(server);
+	registerResources(server);
+	registerPrompts(server);
+	return server;
+}
+async function startServer() {
+	const server = createServer();
+	const transport = new StdioServerTransport();
+	await server.connect(transport);
+	logger.info(`${config.name} v${config.version} started`);
+}
+
+//#endregion
+export { logger as a, colors as i, features as n, EMBEDDING_CONFIG as o, createIndexWatcher as r, config as s, startServer as t };
+//# sourceMappingURL=server-DL8hfycz.mjs.map