@danypops/lector 0.1.7 → 0.1.9

package/src/adapters/polyglot-code-intelligence-index.ts

@@ -0,0 +1,135 @@
+import { extname } from "node:path";
+import type { CallHierarchyEntry, IncomingCall, OutgoingCall } from "../domain/call-hierarchy.ts";
+import type { Diagnostic } from "../domain/diagnostic.ts";
+import type { DocumentSymbolEntry } from "../domain/document-symbol.ts";
+import type { Hover } from "../domain/hover.ts";
+import type { IntelligenceProvenance, IntelligenceSourceOutcome, SymbolSearchBounds } from "../domain/intelligence-provenance.ts";
+import type { LanguageServerDescriptor } from "../domain/language-server-descriptor.ts";
+import type { SymbolSearchResult, WorkspaceLocation, WorkspaceSymbol } from "../domain/workspace-symbol.ts";
+import type { CodeIntelligencePort } from "../ports/code-intelligence-port.ts";
+import type { SymbolIndexPort } from "../ports/symbol-index-port.ts";
+
+const MAX_SOURCE_ERROR_LENGTH = 500;
+const MAX_LANGUAGE_INDEXES = 16;
+const DEFAULT_MAX_RESULTS = 1_000;
+
+export interface PolyglotIndexEntry {
+	readonly descriptor: LanguageServerDescriptor;
+	readonly index: SymbolIndexPort;
+}
+
+function boundedError(error: unknown): { code: string; message: string } {
+	const code = error instanceof Error && error.name ? error.name : "CodeIntelligenceError";
+	const message = (error instanceof Error ? error.message : String(error)).slice(0, MAX_SOURCE_ERROR_LENGTH);
+	return { code, message };
+}
+
+function supportsCodeIntelligence(index: SymbolIndexPort): index is SymbolIndexPort & CodeIntelligencePort {
+	return "goToDefinition" in index && typeof index.goToDefinition === "function";
+}
+
+function compareSymbols(left: WorkspaceSymbol, right: WorkspaceSymbol): number {
+	return (
+		left.location.path.localeCompare(right.location.path) ||
+		left.location.line - right.location.line ||
+		left.location.character - right.location.character ||
+		left.name.localeCompare(right.name) ||
+		left.kind.localeCompare(right.kind)
+	);
+}
+
+export class PolyglotCodeIntelligenceIndex implements SymbolIndexPort, CodeIntelligencePort {
+	readonly provenance: IntelligenceProvenance = {
+		fidelity: "semantic",
+		backend: "polyglot-language-servers",
+		languageId: "polyglot",
+		authority: "language-server",
+		freshness: "live-process",
+		limitations: [],
+	};
+
+	constructor(private readonly entries: readonly PolyglotIndexEntry[]) {
+		if (entries.length === 0 || entries.length > MAX_LANGUAGE_INDEXES) {
+			throw new TypeError(`polyglot index requires between 1 and ${MAX_LANGUAGE_INDEXES} language indexes`);
+		}
+	}
+
+	private indexForPath(path: string): SymbolIndexPort & CodeIntelligencePort {
+		const extension = extname(path);
+		const entry = this.entries.find((candidate) => candidate.descriptor.extensions.includes(extension));
+		if (!entry) throw new Error(`no language index available for extension "${extension}"`);
+		if (!supportsCodeIntelligence(entry.index)) throw new Error(`code intelligence unavailable for ${entry.descriptor.languageId}`);
+		return entry.index;
+	}
+
+	async findSymbols(query: string, bounds: SymbolSearchBounds = { maxResults: DEFAULT_MAX_RESULTS }): Promise<SymbolSearchResult> {
+		if (!Number.isSafeInteger(bounds.maxResults) || bounds.maxResults < 1) throw new TypeError("maxResults must be a positive safe integer");
+		const settled = await Promise.allSettled(this.entries.map(({ index }) => index.findSymbols(query, bounds)));
+		const symbols: WorkspaceSymbol[] = [];
+		const sources: IntelligenceSourceOutcome[] = [];
+		let sourceTruncated = false;
+
+		for (const [position, outcome] of settled.entries()) {
+			const entry = this.entries[position];
+			if (!entry) continue;
+			if (outcome.status === "rejected") {
+				sources.push({ provenance: entry.index.provenance, status: "failed", symbolCount: 0, error: boundedError(outcome.reason) });
+				continue;
+			}
+			sources.push({
+				provenance: outcome.value.provenance,
+				status: "ready",
+				symbolCount: outcome.value.symbols.length,
+				truncated: outcome.value.truncated,
+			});
+			sourceTruncated ||= outcome.value.truncated;
+			for (const symbol of outcome.value.symbols) symbols.push({ ...symbol, provenance: outcome.value.provenance });
+		}
+
+		symbols.sort(compareSymbols);
+		const truncated = sourceTruncated || symbols.length > bounds.maxResults;
+		return {
+			symbols: symbols.slice(0, bounds.maxResults),
+			truncated,
+			provenance: this.provenance,
+			completeness: sources.every((source) => source.status === "ready") ? "complete" : "partial",
+			sources,
+		};
+	}
+
+	goToDefinition(at: WorkspaceLocation) {
+		return this.indexForPath(at.path).goToDefinition(at);
+	}
+
+	goToImplementation(at: WorkspaceLocation) {
+		return this.indexForPath(at.path).goToImplementation(at);
+	}
+
+	findReferences(at: WorkspaceLocation, includeDeclaration: boolean) {
+		return this.indexForPath(at.path).findReferences(at, includeDeclaration);
+	}
+
+	hover(at: WorkspaceLocation): Promise<Hover | undefined> {
+		return this.indexForPath(at.path).hover(at);
+	}
+
+	documentSymbols(path: string): Promise<DocumentSymbolEntry[]> {
+		return this.indexForPath(path).documentSymbols(path);
+	}
+
+	diagnostics(path: string): Promise<Diagnostic[]> {
+		return this.indexForPath(path).diagnostics(path);
+	}
+
+	prepareCallHierarchy(at: WorkspaceLocation): Promise<CallHierarchyEntry[]> {
+		return this.indexForPath(at.path).prepareCallHierarchy(at);
+	}
+
+	incomingCalls(at: WorkspaceLocation): Promise<IncomingCall[]> {
+		return this.indexForPath(at.path).incomingCalls(at);
+	}
+
+	outgoingCalls(at: WorkspaceLocation): Promise<OutgoingCall[]> {
+		return this.indexForPath(at.path).outgoingCalls(at);
+	}
+}

package/src/adapters/sqlite-symbol-graph.ts

@@ -1,5 +1,6 @@
 import type { Database } from "bun:sqlite";
 import { type Migration, openSqliteWithPragmas } from "@danypops/daemon-kit/storage";
+import type { IntelligenceProvenance } from "../domain/intelligence-provenance.ts";
 import type { SymbolGraphGeneration } from "../domain/symbol-graph-generation.ts";
 import type { SymbolNodeId } from "../domain/symbol-node-id.ts";
 import type { SymbolEdgeKind, SymbolGraphPort, SymbolNode } from "../ports/symbol-graph-port.ts";
@@ -23,6 +24,14 @@ const MIGRATIONS: Migration[] = [
 			);
 		},
 	},
+	{
+		version: 3,
+		up: (db) => db.exec("ALTER TABLE symbol_graph_generation ADD COLUMN provenance_json TEXT"),
+	},
+	{
+		version: 4,
+		up: (db) => db.exec("ALTER TABLE symbol_graph_generation ADD COLUMN sources_json TEXT"),
+	},
 ];
 
 interface NodeRow {
@@ -42,6 +51,56 @@ interface GenerationRow {
 	symbols_processed: number;
 	nodes_added: number;
 	edges_added: number;
+	provenance_json: string | null;
+	sources_json: string | null;
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+	return typeof value === "object" && value !== null;
+}
+
+function asProvenance(value: unknown): IntelligenceProvenance | undefined {
+	if (!isRecord(value)) return undefined;
+	const candidate = value;
+	if (
+		(candidate.fidelity !== "semantic" && candidate.fidelity !== "structural") ||
+		typeof candidate.backend !== "string" ||
+		typeof candidate.languageId !== "string" ||
+		(candidate.authority !== "language-server" && candidate.authority !== "parser" && candidate.authority !== "compiler") ||
+		(candidate.freshness !== "live-process" && candidate.freshness !== "content-hash" && candidate.freshness !== "filesystem-snapshot") ||
+		!Array.isArray(candidate.limitations) ||
+		!candidate.limitations.every((item) => typeof item === "string")
+	) {
+		return undefined;
+	}
+	return {
+		fidelity: candidate.fidelity,
+		backend: candidate.backend,
+		languageId: candidate.languageId,
+		authority: candidate.authority,
+		freshness: candidate.freshness,
+		limitations: candidate.limitations,
+	};
+}
+
+function parseJson(json: string | null): unknown {
+	if (!json) return undefined;
+	try {
+		return JSON.parse(json);
+	} catch {
+		return undefined;
+	}
+}
+
+function parseProvenance(json: string | null): IntelligenceProvenance | undefined {
+	return asProvenance(parseJson(json));
+}
+
+function parseSources(json: string | null): readonly IntelligenceProvenance[] | undefined {
+	const value = parseJson(json);
+	if (!Array.isArray(value)) return undefined;
+	const sources = value.map(asProvenance);
+	return sources.every((source) => source !== undefined) ? sources : undefined;
 }
 
 /**
@@ -105,7 +164,7 @@ export class SqliteSymbolGraph implements SymbolGraphPort {
 			SELECT DISTINCT id FROM reachable
 		`;
 		const params: Record<string, string | number> = { $id: id, $maxDepth: options.maxDepth };
-		if (options.kind) params["$kind"] = options.kind;
+		if (options.kind) params.$kind = options.kind;
 		const rows = this.db.query(sql).all(params) as { id: string }[];
 		return rows.map((row) => row.id).filter((reachedId) => reachedId !== id);
 	}
@@ -113,15 +172,19 @@ export class SqliteSymbolGraph implements SymbolGraphPort {
 	async getGeneration(): Promise<SymbolGraphGeneration | undefined> {
 		const row = this.db
 			.query(
-				"SELECT source_fingerprint, max_files, max_symbols_per_file, completed_at, files_processed, symbols_processed, nodes_added, edges_added FROM symbol_graph_generation WHERE singleton = 1",
+				"SELECT source_fingerprint, max_files, max_symbols_per_file, completed_at, files_processed, symbols_processed, nodes_added, edges_added, provenance_json, sources_json FROM symbol_graph_generation WHERE singleton = 1",
 			)
 			.get() as GenerationRow | null;
 		if (!row) return undefined;
+		const provenance = parseProvenance(row.provenance_json);
+		const sources = parseSources(row.sources_json);
 		return {
 			sourceFingerprint: row.source_fingerprint,
 			maxFiles: row.max_files,
 			maxSymbolsPerFile: row.max_symbols_per_file,
 			completedAt: row.completed_at,
+			...(provenance ? { provenance } : {}),
+			...(sources ? { sources } : {}),
 			result: {
 				filesProcessed: row.files_processed,
 				symbolsProcessed: row.symbols_processed,
@@ -134,7 +197,7 @@ export class SqliteSymbolGraph implements SymbolGraphPort {
 	async setGeneration(generation: SymbolGraphGeneration): Promise<void> {
 		this.db
 			.query(
-				"INSERT INTO symbol_graph_generation (singleton, source_fingerprint, max_files, max_symbols_per_file, completed_at, files_processed, symbols_processed, nodes_added, edges_added) VALUES (1, ?, ?, ?, ?, ?, ?, ?, ?) ON CONFLICT(singleton) DO UPDATE SET source_fingerprint = excluded.source_fingerprint, max_files = excluded.max_files, max_symbols_per_file = excluded.max_symbols_per_file, completed_at = excluded.completed_at, files_processed = excluded.files_processed, symbols_processed = excluded.symbols_processed, nodes_added = excluded.nodes_added, edges_added = excluded.edges_added",
+				"INSERT INTO symbol_graph_generation (singleton, source_fingerprint, max_files, max_symbols_per_file, completed_at, files_processed, symbols_processed, nodes_added, edges_added, provenance_json, sources_json) VALUES (1, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?) ON CONFLICT(singleton) DO UPDATE SET source_fingerprint = excluded.source_fingerprint, max_files = excluded.max_files, max_symbols_per_file = excluded.max_symbols_per_file, completed_at = excluded.completed_at, files_processed = excluded.files_processed, symbols_processed = excluded.symbols_processed, nodes_added = excluded.nodes_added, edges_added = excluded.edges_added, provenance_json = excluded.provenance_json, sources_json = excluded.sources_json",
 			)
 			.run(
 				generation.sourceFingerprint,
@@ -145,6 +208,8 @@ export class SqliteSymbolGraph implements SymbolGraphPort {
 				generation.result.symbolsProcessed,
 				generation.result.nodesAdded,
 				generation.result.edgesAdded,
+				generation.provenance ? JSON.stringify(generation.provenance) : null,
+				generation.sources ? JSON.stringify(generation.sources) : null,
 			);
 	}
 

package/src/adapters/tree-sitter/typescript-tree-sitter-symbol-index.ts

@@ -1,15 +1,32 @@
-import { readFileSync } from "node:fs";
+import { readFileSync, statSync } from "node:fs";
 import { extname, join } from "node:path";
 import { fileURLToPath } from "node:url";
 import Parser from "web-tree-sitter";
 import { contentHashOf } from "../../domain/content-hash.ts";
-import type { WorkspaceSymbol } from "../../domain/workspace-symbol.ts";
+import type { IntelligenceProvenance, SymbolSearchBounds } from "../../domain/intelligence-provenance.ts";
+import type { SymbolSearchResult, WorkspaceSymbol } from "../../domain/workspace-symbol.ts";
 import type { ContentCachePort, ContentSymbol } from "../../ports/content-cache-port.ts";
 import type { SymbolIndexPort } from "../../ports/symbol-index-port.ts";
 import { findSourceFiles } from "../find-source-files.ts";
 import { InMemoryContentCache } from "../in-memory-content-cache.ts";
 
-const MAX_FILES_SCANNED = 5_000;
+const DEFAULT_MAX_FILES = 5_000;
+const DEFAULT_MAX_FILE_BYTES = 2 * 1024 * 1024;
+const DEFAULT_MAX_TOTAL_BYTES = 50 * 1024 * 1024;
+const DEFAULT_MAX_RESULTS = 1_000;
+
+export interface TreeSitterSymbolIndexOptions {
+	readonly maxFiles?: number;
+	readonly maxFileBytes?: number;
+	readonly maxTotalBytes?: number;
+	readonly maxResults?: number;
+}
+
+function positiveLimit(value: number | undefined, fallback: number, field: string): number {
+	const result = value ?? fallback;
+	if (!Number.isSafeInteger(result) || result < 1) throw new TypeError(`${field} must be a positive safe integer`);
+	return result;
+}
 
 interface DeclarationKind {
 	readonly nodeType: string;
@@ -86,13 +103,29 @@ function toWorkspaceSymbols(symbols: readonly ContentSymbol[], relativePath: str
  * read to compute it.
  */
 export class TreeSitterSymbolIndex implements SymbolIndexPort {
+	readonly provenance: IntelligenceProvenance = {
+		fidelity: "structural",
+		backend: "tree-sitter-typescript-javascript",
+		languageId: "typescript-javascript",
+		authority: "parser",
+		freshness: "content-hash",
+		limitations: ["no cross-file identity", "no type information", "syntax recovery may include malformed declarations"],
+	};
 	private readonly rootPath: string;
 	private readonly contentCache: ContentCachePort;
+	private readonly maxFiles: number;
+	private readonly maxFileBytes: number;
+	private readonly maxTotalBytes: number;
+	private readonly maxResults: number;
 	private readonly parsersByWasmPath = new Map<string, Parser>();
 
-	constructor(rootPath: string, contentCache: ContentCachePort = new InMemoryContentCache()) {
+	constructor(rootPath: string, contentCache: ContentCachePort = new InMemoryContentCache(), options: TreeSitterSymbolIndexOptions = {}) {
 		this.rootPath = rootPath;
 		this.contentCache = contentCache;
+		this.maxFiles = positiveLimit(options.maxFiles, DEFAULT_MAX_FILES, "maxFiles");
+		this.maxFileBytes = positiveLimit(options.maxFileBytes, DEFAULT_MAX_FILE_BYTES, "maxFileBytes");
+		this.maxTotalBytes = positiveLimit(options.maxTotalBytes, DEFAULT_MAX_TOTAL_BYTES, "maxTotalBytes");
+		this.maxResults = positiveLimit(options.maxResults, DEFAULT_MAX_RESULTS, "maxResults");
 	}
 
 	private async parserFor(wasmPath: string): Promise<Parser> {
@@ -106,7 +139,7 @@ export class TreeSitterSymbolIndex implements SymbolIndexPort {
 		return parser;
 	}
 
-	private async contentSymbolsFor(relativePath: string, wasmPath: string, content: string): Promise<ContentSymbol[]> {
+	private async contentSymbolsFor(wasmPath: string, content: string): Promise<ContentSymbol[]> {
 		const hash = contentHashOf(content);
 
 		// Reading the file already required reading its content -- warm the fs lens for this
@@ -125,28 +158,45 @@ export class TreeSitterSymbolIndex implements SymbolIndexPort {
 		return symbols;
 	}
 
-	async findSymbols(query: string): Promise<WorkspaceSymbol[]> {
+	async findSymbols(query: string, bounds: SymbolSearchBounds = { maxResults: this.maxResults }): Promise<SymbolSearchResult> {
+		const maxResults = Math.min(positiveLimit(bounds.maxResults, this.maxResults, "maxResults"), this.maxResults);
 		const lowerQuery = query.toLowerCase();
 		const results: WorkspaceSymbol[] = [];
+		const files = findSourceFiles(this.rootPath, (extension) => wasmPathFor(extension) !== undefined, this.maxFiles);
+		let totalBytes = 0;
+		let truncated = files.length === this.maxFiles;
 
-		for (const relativePath of findSourceFiles(this.rootPath, (extension) => wasmPathFor(extension) !== undefined, MAX_FILES_SCANNED)) {
+		for (const relativePath of files) {
 			const wasmPath = wasmPathFor(extname(relativePath));
 			if (!wasmPath) continue;
 
 			let content: string;
 			try {
-				content = readFileSync(join(this.rootPath, relativePath), "utf-8");
+				const absolutePath = join(this.rootPath, relativePath);
+				const size = statSync(absolutePath).size;
+				if (size > this.maxFileBytes || totalBytes + size > this.maxTotalBytes) {
+					truncated = true;
+					continue;
+				}
+				totalBytes += size;
+				content = readFileSync(absolutePath, "utf-8");
 			} catch {
 				continue;
 			}
 
-			const contentSymbols = await this.contentSymbolsFor(relativePath, wasmPath, content);
+			const contentSymbols = await this.contentSymbolsFor(wasmPath, content);
 			for (const symbol of toWorkspaceSymbols(contentSymbols, relativePath)) {
-				if (symbol.name.toLowerCase().includes(lowerQuery)) results.push(symbol);
+				if (!symbol.name.toLowerCase().includes(lowerQuery)) continue;
+				if (results.length === maxResults) {
+					truncated = true;
+					break;
+				}
+				results.push(symbol);
 			}
+			if (results.length === maxResults) break;
 		}
 
-		return results;
+		return { symbols: results, truncated, provenance: this.provenance };
 	}
 
 	async close(): Promise<void> {

package/src/adapters/typescript-compiler-symbol-index.ts

@@ -0,0 +1,129 @@
+import { readFileSync, statSync } from "node:fs";
+import { extname, join } from "node:path";
+import ts from "typescript";
+import type { IntelligenceProvenance, SymbolSearchBounds } from "../domain/intelligence-provenance.ts";
+import type { SymbolSearchResult, WorkspaceSymbol } from "../domain/workspace-symbol.ts";
+import type { SymbolIndexPort } from "../ports/symbol-index-port.ts";
+import { findSourceFiles } from "./find-source-files.ts";
+
+const SOURCE_EXTENSIONS = new Set([".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs"]);
+
+export interface TypeScriptCompilerSymbolIndexOptions {
+	readonly maxFiles?: number;
+	readonly maxFileBytes?: number;
+	readonly maxTotalBytes?: number;
+	readonly maxResults?: number;
+	readonly maxNodesPerFile?: number;
+}
+
+function positiveLimit(value: number | undefined, fallback: number, field: string): number {
+	const result = value ?? fallback;
+	if (!Number.isSafeInteger(result) || result < 1) throw new TypeError(`${field} must be a positive safe integer`);
+	return result;
+}
+
+function scriptKind(path: string): ts.ScriptKind {
+	switch (extname(path)) {
+		case ".tsx":
+			return ts.ScriptKind.TSX;
+		case ".jsx":
+			return ts.ScriptKind.JSX;
+		case ".js":
+		case ".mjs":
+		case ".cjs":
+			return ts.ScriptKind.JS;
+		default:
+			return ts.ScriptKind.TS;
+	}
+}
+
+function declaration(node: ts.Node): { name: ts.Node; kind: string } | undefined {
+	if (ts.isFunctionDeclaration(node) && node.name) return { name: node.name, kind: "function" };
+	if (ts.isClassDeclaration(node) && node.name) return { name: node.name, kind: "class" };
+	if (ts.isInterfaceDeclaration(node)) return { name: node.name, kind: "interface" };
+	if (ts.isTypeAliasDeclaration(node)) return { name: node.name, kind: "type-alias" };
+	if (ts.isEnumDeclaration(node)) return { name: node.name, kind: "enum" };
+	if (ts.isMethodDeclaration(node)) return { name: node.name, kind: "method" };
+	if (ts.isVariableDeclaration(node) && ts.isIdentifier(node.name)) return { name: node.name, kind: "variable" };
+	return undefined;
+}
+
+export class TypeScriptCompilerSymbolIndex implements SymbolIndexPort {
+	readonly provenance: IntelligenceProvenance = {
+		fidelity: "structural",
+		backend: "typescript-compiler",
+		languageId: "typescript-javascript",
+		authority: "compiler",
+		freshness: "filesystem-snapshot",
+		limitations: ["syntax declarations only", "no cross-file identity", "no language-server project state"],
+	};
+	private readonly maxFiles: number;
+	private readonly maxFileBytes: number;
+	private readonly maxTotalBytes: number;
+	private readonly maxResults: number;
+	private readonly maxNodesPerFile: number;
+
+	constructor(
+		private readonly rootPath: string,
+		options: TypeScriptCompilerSymbolIndexOptions = {},
+	) {
+		this.maxFiles = positiveLimit(options.maxFiles, 5_000, "maxFiles");
+		this.maxFileBytes = positiveLimit(options.maxFileBytes, 2 * 1024 * 1024, "maxFileBytes");
+		this.maxTotalBytes = positiveLimit(options.maxTotalBytes, 50 * 1024 * 1024, "maxTotalBytes");
+		this.maxResults = positiveLimit(options.maxResults, 1_000, "maxResults");
+		this.maxNodesPerFile = positiveLimit(options.maxNodesPerFile, 100_000, "maxNodesPerFile");
+	}
+
+	findSymbols(query: string, bounds: SymbolSearchBounds = { maxResults: this.maxResults }): Promise<SymbolSearchResult> {
+		const maxResults = Math.min(positiveLimit(bounds.maxResults, this.maxResults, "maxResults"), this.maxResults);
+		const files = findSourceFiles(this.rootPath, (extension) => SOURCE_EXTENSIONS.has(extension), this.maxFiles);
+		const symbols: WorkspaceSymbol[] = [];
+		const lowerQuery = query.toLowerCase();
+		let totalBytes = 0;
+		let truncated = files.length === this.maxFiles;
+
+		for (const relativePath of files) {
+			const absolutePath = join(this.rootPath, relativePath);
+			let sourceText: string;
+			try {
+				const size = statSync(absolutePath).size;
+				if (size > this.maxFileBytes || totalBytes + size > this.maxTotalBytes) {
+					truncated = true;
+					continue;
+				}
+				totalBytes += size;
+				sourceText = readFileSync(absolutePath, "utf-8");
+			} catch {
+				continue;
+			}
+
+			const sourceFile = ts.createSourceFile(relativePath, sourceText, ts.ScriptTarget.Latest, true, scriptKind(relativePath));
+			let visited = 0;
+			const visit = (node: ts.Node): void => {
+				if (visited++ >= this.maxNodesPerFile || symbols.length >= maxResults) {
+					truncated = true;
+					return;
+				}
+				const found = declaration(node);
+				if (found) {
+					const name = found.name.getText(sourceFile);
+					if (name.toLowerCase().includes(lowerQuery)) {
+						const position = sourceFile.getLineAndCharacterOfPosition(found.name.getStart(sourceFile));
+						symbols.push({ name, kind: found.kind, location: { path: relativePath, line: position.line + 1, character: position.character + 1 } });
+					}
+				}
+				if (visited < this.maxNodesPerFile && symbols.length < maxResults) ts.forEachChild(node, visit);
+				else if (node.getChildCount(sourceFile) > 0) truncated = true;
+			};
+			visit(sourceFile);
+			if (symbols.length >= maxResults) {
+				truncated = true;
+				break;
+			}
+		}
+
+		return Promise.resolve({ symbols, truncated, provenance: this.provenance });
+	}
+
+	async close(): Promise<void> {}
+}