@shanepadgett/tau-agent 0.33.1 → 0.34.0

package/{extensions/explore → src}/ast/queries/context.ts

@@ -182,13 +182,19 @@ async function snapsFromCalleeSites(
 ): Promise<DeclSnap[]> {
 	const out: DeclSnap[] = [];
 	const seen = new Set<string>();
-	const seenNames = new Set<string>();
 	for (const site of sites) {
 		signal.throwIfAborted();
-		if (site.name.length === 0 || seenNames.has(site.name)) continue;
-		seenNames.add(site.name);
-		const resolution = await resolveTarget(engine, scopeDir, { name: site.name }, signal);
+		if (site.target === undefined) continue;
+		const resolution = await resolveTarget(
+			engine,
+			scopeDir,
+			{ path: site.target.path, name: site.name, line: site.target.startLine },
+			signal,
+		);
 		if (resolution.kind !== "resolved") continue;
+		if (site.kind === "construct" ? !isTypeLike(resolution.decl.kind) : !isCallableLike(resolution.decl.kind)) {
+			continue;
+		}
 		const item: DeclSnap = {
 			path: resolution.path,
 			decl: resolution.decl,
@@ -261,9 +267,13 @@ function packInto(
 	}
 }
 
-function packTarget(state: PackState, snap: DeclSnap): void {
+/**
+ * Type-like targets print signature plus members (the `methods` group covers the
+ * bodies); callable targets print their own body.
+ */
+function packTarget(state: PackState, snap: DeclSnap, targetKind: DeclKind): void {
 	const left = state.budget - state.used;
-	const preferBody = !bodyUnavailable(snap);
+	const preferBody = !bodyUnavailable(snap) && !isTypeLike(targetKind);
 	if (preferBody) {
 		const body = entryFrom(snap, "body", []);
 		if (body.tokens <= left && body.text.length > 0) {
@@ -273,7 +283,7 @@ function packTarget(state: PackState, snap: DeclSnap): void {
 			return;
 		}
 	}
-	const flags: ContextFlag[] = ["target_omitted"];
+	const flags: ContextFlag[] = isTypeLike(targetKind) ? [] : ["target_omitted"];
 	if (bodyUnavailable(snap)) flags.push("body_unavailable");
 	const signature = entryFrom(snap, "signature", flags);
 	if (signature.tokens <= left && signature.text.length > 0) {
@@ -289,6 +299,102 @@ function packTarget(state: PackState, snap: DeclSnap): void {
  * Budgeted symbol pack. Bodies/signatures via show view extraction.
  * Depth-2 is a capped second resolve+query pass — no relationship depth param.
  */
+async function collectDepth2(
+	args: ContextQueryArgs,
+	state: PackState,
+	snaps: DeclSnap[],
+	mode: "callees" | "callers",
+	scopeDir: string,
+	followUps: { count: number },
+): Promise<DeclSnap[]> {
+	const { engine, signal } = args;
+	const out: DeclSnap[] = [];
+	for (const snap of snaps) {
+		if (followUps.count >= CONTEXT_FOLLOWUP_N || state.used >= state.budget) break;
+		signal.throwIfAborted();
+		followUps.count += 1;
+		const sites = await relSites(args, mode, {
+			path: snap.path,
+			name: snap.decl.name,
+			qualifiedName: snap.decl.qualifiedName,
+			kind: snap.decl.kind,
+			startLine: snap.decl.startLine,
+		});
+		const items =
+			mode === "callees"
+				? await snapsFromCalleeSites(engine, scopeDir, sites, signal)
+				: await snapsFromSites(engine, sites, signal, (d) => isCallableLike(d.kind));
+		for (const item of items) {
+			if (!state.seen.has(snapKey(item))) out.push(item);
+		}
+	}
+	return out;
+}
+
+async function packCallableContext(
+	args: ContextQueryArgs,
+	state: PackState,
+	target: CompositeTarget,
+	scopeDir: string,
+): Promise<void> {
+	const { engine, signal } = args;
+	const calleeSites = await relSites(args, "callees", target);
+	const calleeSnaps = await snapsFromCalleeSites(engine, scopeDir, calleeSites, signal);
+	packInto(state, "callees", "direct callees", calleeSnaps, true);
+
+	const callerSites = await relSites(args, "callers", target);
+	const callerSnaps = await snapsFromSites(engine, callerSites, signal, (d) => isCallableLike(d.kind));
+	packInto(state, "callers", "direct callers", callerSnaps, false);
+
+	const followUps = { count: 0 };
+	const depth2Callees = await collectDepth2(args, state, calleeSnaps, "callees", scopeDir, followUps);
+	packInto(state, "calleesDepth2", "depth-2 callees", depth2Callees, false);
+	const depth2Callers = await collectDepth2(args, state, callerSnaps, "callers", scopeDir, followUps);
+	packInto(state, "callersDepth2", "depth-2 callers", depth2Callers, false);
+}
+
+async function packTypeContext(
+	args: ContextQueryArgs,
+	state: PackState,
+	target: CompositeTarget,
+	decl: Decl,
+	ir: FileIr,
+	source: string,
+): Promise<void> {
+	const { engine, signal } = args;
+	const implSites = await relSites(args, "implementations", target);
+	const implSnaps = await snapsFromSites(engine, implSites, signal, (d) => isTypeLike(d.kind));
+	packInto(state, "implementors", "implementors", implSnaps, true);
+
+	const methods: DeclSnap[] = [];
+	for (const child of decl.children) {
+		if (!isCallableLike(child.kind)) continue;
+		if (methods.length >= CONTEXT_METHOD_CAP) break;
+		methods.push({ path: target.path, decl: child, ir, source });
+	}
+	packInto(state, "methods", "methods", methods, true);
+
+	const dependents: DeclSnap[] = [];
+	for (const method of methods) {
+		if (state.used >= state.budget) break;
+		signal.throwIfAborted();
+		const sites = await relSites(args, "callers", {
+			path: method.path,
+			name: method.decl.name,
+			qualifiedName: method.decl.qualifiedName,
+			kind: method.decl.kind,
+			startLine: method.decl.startLine,
+		});
+		// Method-name matching collects unrelated same-name callers; ambiguous
+		// entries would spend budget correct ones need.
+		const certain = sites.filter((site) => site.certainty !== "ambiguous");
+		for (const item of await snapsFromSites(engine, certain, signal, (d) => isCallableLike(d.kind))) {
+			if (!state.seen.has(snapKey(item))) dependents.push(item);
+		}
+	}
+	packInto(state, "dependents", "dependents", dependents, false);
+}
+
 export async function queryContext(args: ContextQueryArgs): Promise<ContextResult> {
 	const { engine, signal } = args;
 	if (args.budget < 1) {
@@ -317,82 +423,12 @@ export async function queryContext(args: ContextQueryArgs): Promise<ContextResul
 		groups: [],
 	};
 
-	packTarget(state, targetSnap);
+	packTarget(state, targetSnap, kind);
 
 	if (isCallableLike(kind)) {
-		const calleeSites = await relSites(args, "callees", target);
-		const calleeSnaps = await snapsFromCalleeSites(engine, scopeDir, calleeSites, signal);
-		packInto(state, "callees", "direct callees", calleeSnaps, true);
-
-		const callerSites = await relSites(args, "callers", target);
-		const callerSnaps = await snapsFromSites(engine, callerSites, signal, (d) => isCallableLike(d.kind));
-		packInto(state, "callers", "direct callers", callerSnaps, false);
-
-		let followUps = 0;
-		const depth2Callees: DeclSnap[] = [];
-		for (const snap of calleeSnaps) {
-			if (followUps >= CONTEXT_FOLLOWUP_N || state.used >= state.budget) break;
-			signal.throwIfAborted();
-			followUps += 1;
-			const sites = await relSites(args, "callees", {
-				path: snap.path,
-				name: snap.decl.name,
-				qualifiedName: snap.decl.qualifiedName,
-				kind: snap.decl.kind,
-				startLine: snap.decl.startLine,
-			});
-			for (const item of await snapsFromCalleeSites(engine, scopeDir, sites, signal)) {
-				if (!state.seen.has(snapKey(item))) depth2Callees.push(item);
-			}
-		}
-		packInto(state, "calleesDepth2", "depth-2 callees", depth2Callees, false);
-
-		const depth2Callers: DeclSnap[] = [];
-		for (const snap of callerSnaps) {
-			if (followUps >= CONTEXT_FOLLOWUP_N || state.used >= state.budget) break;
-			signal.throwIfAborted();
-			followUps += 1;
-			const sites = await relSites(args, "callers", {
-				path: snap.path,
-				name: snap.decl.name,
-				qualifiedName: snap.decl.qualifiedName,
-				kind: snap.decl.kind,
-				startLine: snap.decl.startLine,
-			});
-			for (const item of await snapsFromSites(engine, sites, signal, (d) => isCallableLike(d.kind))) {
-				if (!state.seen.has(snapKey(item))) depth2Callers.push(item);
-			}
-		}
-		packInto(state, "callersDepth2", "depth-2 callers", depth2Callers, false);
+		await packCallableContext(args, state, target, scopeDir);
 	} else {
-		const implSites = await relSites(args, "implementations", target);
-		const implSnaps = await snapsFromSites(engine, implSites, signal, (d) => isTypeLike(d.kind));
-		packInto(state, "implementors", "implementors", implSnaps, true);
-
-		const methods: DeclSnap[] = [];
-		for (const child of decl.children) {
-			if (!isCallableLike(child.kind)) continue;
-			if (methods.length >= CONTEXT_METHOD_CAP) break;
-			methods.push({ path: target.path, decl: child, ir, source });
-		}
-		packInto(state, "methods", "methods", methods, true);
-
-		const dependents: DeclSnap[] = [];
-		for (const method of methods) {
-			if (state.used >= state.budget) break;
-			signal.throwIfAborted();
-			const sites = await relSites(args, "callers", {
-				path: method.path,
-				name: method.decl.name,
-				qualifiedName: method.decl.qualifiedName,
-				kind: method.decl.kind,
-				startLine: method.decl.startLine,
-			});
-			for (const item of await snapsFromSites(engine, sites, signal, (d) => isCallableLike(d.kind))) {
-				if (!state.seen.has(snapKey(item))) dependents.push(item);
-			}
-		}
-		packInto(state, "dependents", "dependents", dependents, false);
+		await packTypeContext(args, state, target, decl, ir, source);
 	}
 
 	return {

package/{extensions/explore → src}/ast/queries/discover.ts

@@ -4,7 +4,7 @@ import type { Decl, DeclKind, Visibility } from "../ir.ts";
 import { packageDeclKey, type PackageSurfaceHost } from "../package-surface.ts";
 import { scanSources, type ScanOutcome } from "../scan.ts";
 import { docsText, signatureText } from "../slice.ts";
-import { pathResolutionError, resolveExplorePath } from "../../traverse.ts";
+import { pathResolutionError, resolveExplorePath } from "../traverse.ts";
 
 export type DiscoverSurface = "all" | "public" | "private" | "sourceExport" | "packageSurface";
 
@@ -54,10 +54,14 @@ function nameFields(decl: Decl): [string, string] {
 }
 
 function matchesNameQuery(kind: "exactName" | "prefixName" | "substringName", needle: string, decl: Decl): boolean {
+	// Every language in the sweep capitalizes types and lowercases functions, so
+	// non-exact matching folds case; exactName stays exact.
+	const folded = needle.toLowerCase();
 	for (const field of nameFields(decl)) {
 		if (kind === "exactName" && field === needle) return true;
-		if (kind === "prefixName" && field.startsWith(needle)) return true;
-		if (kind === "substringName" && field.includes(needle)) return true;
+		const lower = field.toLowerCase();
+		if (kind === "prefixName" && lower.startsWith(folded)) return true;
+		if (kind === "substringName" && lower.includes(folded)) return true;
 	}
 	return false;
 }
@@ -87,6 +91,20 @@ function fuzzyScore(query: string, text: string): number | undefined {
 	return dist === undefined ? undefined : 1000 + dist;
 }
 
+function levenshteinRow(prev: number[], cur: number[], b: string, ca: number, maxDist: number): number {
+	let rowMin = cur[0] ?? maxDist + 1;
+	for (let j = 1; j <= b.length; j += 1) {
+		const cost = ca === b.charCodeAt(j - 1) ? 0 : 1;
+		const del = (prev[j] ?? maxDist + 1) + 1;
+		const ins = (cur[j - 1] ?? maxDist + 1) + 1;
+		const sub = (prev[j - 1] ?? maxDist + 1) + cost;
+		const v = Math.min(del, ins, sub);
+		cur[j] = v;
+		if (v < rowMin) rowMin = v;
+	}
+	return rowMin;
+}
+
 function boundedLevenshtein(a: string, b: string, maxDist: number): number | undefined {
 	if (Math.abs(a.length - b.length) > maxDist) return undefined;
 	const prev = Array.from({ length: b.length + 1 }, () => 0);
@@ -94,17 +112,7 @@ function boundedLevenshtein(a: string, b: string, maxDist: number): number | und
 	for (let j = 0; j <= b.length; j += 1) prev[j] = j;
 	for (let i = 1; i <= a.length; i += 1) {
 		cur[0] = i;
-		let rowMin = cur[0] ?? i;
-		const ca = a.charCodeAt(i - 1);
-		for (let j = 1; j <= b.length; j += 1) {
-			const cost = ca === b.charCodeAt(j - 1) ? 0 : 1;
-			const del = (prev[j] ?? maxDist + 1) + 1;
-			const ins = (cur[j - 1] ?? maxDist + 1) + 1;
-			const sub = (prev[j - 1] ?? maxDist + 1) + cost;
-			const v = Math.min(del, ins, sub);
-			cur[j] = v;
-			if (v < rowMin) rowMin = v;
-		}
+		const rowMin = levenshteinRow(prev, cur, b, a.charCodeAt(i - 1), maxDist);
 		if (rowMin > maxDist) return undefined;
 		for (let j = 0; j <= b.length; j += 1) prev[j] = cur[j] ?? 0;
 	}
@@ -113,11 +121,14 @@ function boundedLevenshtein(a: string, b: string, maxDist: number): number | und
 }
 
 function bestFuzzyScore(query: string, decl: Decl): number | undefined {
+	const folded = query.toLowerCase();
 	let best: number | undefined;
 	for (const field of nameFields(decl)) {
-		const score = fuzzyScore(query, field);
+		const score = fuzzyScore(folded, field.toLowerCase());
 		if (score === undefined) continue;
-		if (best === undefined || score < best) best = score;
+		// Same-case hits still sort ahead of case-folded ones inside a tier.
+		const adjusted = field.includes(query) ? score : score + 0.5;
+		if (best === undefined || adjusted < best) best = adjusted;
 	}
 	return best;
 }
@@ -201,6 +212,57 @@ function newBucket(query: DiscoverQuery): MatchBucket {
 	};
 }
 
+function consumeWork(bucket: MatchBucket, maxWork: number): boolean {
+	bucket.workUsed += 1;
+	if (bucket.workUsed <= maxWork) return true;
+	bucket.workLimitReached = true;
+	return false;
+}
+
+function considerFuzzy(
+	bucket: MatchBucket,
+	query: Extract<DiscoverQuery, { kind: "fuzzyName" }>,
+	path: string,
+	decl: Decl,
+	source: string,
+	access: string | undefined,
+): void {
+	if (!consumeWork(bucket, query.maxWork)) return;
+	const score = bestFuzzyScore(query.name, decl);
+	if (score === undefined) return;
+	const candidate = toCandidate(path, decl, source, access);
+	const worst = bucket.scored[bucket.scored.length - 1];
+	if (bucket.scored.length >= query.maxCandidates && worst !== undefined && score >= worst.score) {
+		bucket.candidateLimitReached = true;
+		return;
+	}
+	const before = bucket.scored.length;
+	insertScored(bucket.scored, { score, candidate }, query.maxCandidates);
+	if (before === query.maxCandidates) bucket.candidateLimitReached = true;
+}
+
+function considerDocumentation(
+	bucket: MatchBucket,
+	query: Extract<DiscoverQuery, { kind: "documentation" }>,
+	path: string,
+	decl: Decl,
+	source: string,
+	access: string | undefined,
+): void {
+	if (decl.docStartOffset === undefined || decl.docEndOffset === undefined) return;
+	if (!consumeWork(bucket, query.maxWork)) return;
+	const docs = docsText(decl, source);
+	if (docs === undefined) return;
+	const foldedDocs = docs.toLowerCase();
+	if (!query.terms.every((term) => foldedDocs.includes(term.toLowerCase()))) return;
+	if (bucket.scored.length >= query.maxCandidates) {
+		bucket.candidateLimitReached = true;
+		return;
+	}
+	bucket.scored.push({ score: bucket.scored.length, candidate: toCandidate(path, decl, source, access) });
+	if (bucket.scored.length >= query.maxCandidates) bucket.candidateLimitReached = true;
+}
+
 function considerDecl(
 	bucket: MatchBucket,
 	query: DiscoverQuery,
@@ -231,41 +293,11 @@ function considerDecl(
 			bucket.plain.push(toCandidate(path, decl, source, access));
 			return;
 		}
-		case "fuzzyName": {
-			bucket.workUsed += 1;
-			if (bucket.workUsed > query.maxWork) {
-				bucket.workLimitReached = true;
-				return;
-			}
-			const score = bestFuzzyScore(query.name, decl);
-			if (score === undefined) return;
-			const candidate = toCandidate(path, decl, source, access);
-			const worst = bucket.scored[bucket.scored.length - 1];
-			if (bucket.scored.length >= query.maxCandidates && worst !== undefined && score >= worst.score) {
-				bucket.candidateLimitReached = true;
-				return;
-			}
-			const before = bucket.scored.length;
-			insertScored(bucket.scored, { score, candidate }, query.maxCandidates);
-			if (before === query.maxCandidates) bucket.candidateLimitReached = true;
+		case "fuzzyName":
+			considerFuzzy(bucket, query, path, decl, source, access);
 			return;
-		}
-		case "documentation": {
-			if (decl.docStartOffset === undefined || decl.docEndOffset === undefined) return;
-			bucket.workUsed += 1;
-			if (bucket.workUsed > query.maxWork) {
-				bucket.workLimitReached = true;
-				return;
-			}
-			const docs = docsText(decl, source);
-			if (docs === undefined || !query.terms.every((term) => docs.includes(term))) return;
-			if (bucket.scored.length >= query.maxCandidates) {
-				bucket.candidateLimitReached = true;
-				return;
-			}
-			bucket.scored.push({ score: bucket.scored.length, candidate: toCandidate(path, decl, source, access) });
-			if (bucket.scored.length >= query.maxCandidates) bucket.candidateLimitReached = true;
-		}
+		case "documentation":
+			considerDocumentation(bucket, query, path, decl, source, access);
 	}
 }
 
@@ -338,68 +370,68 @@ function packageSurfaceHost(engine: ExploreEngine): PackageSurfaceHost {
 	};
 }
 
-/** Directory-scoped declaration discovery. Language rules stay on adapters. */
-export async function discover(
+async function discoverPackageSurface(
 	engine: ExploreEngine,
-	pathInput: string,
+	absolutePath: string,
 	query: DiscoverQuery,
-	surface: DiscoverSurface,
 	resultLimit: number,
 	signal: AbortSignal,
 ): Promise<DiscoverResult> {
-	signal.throwIfAborted();
-	const absolutePath = resolveExplorePath(engine.cwd, pathInput);
-	await pathIsDirectory(absolutePath, pathInput);
-
-	const bucket = newBucket(query);
-
-	if (surface === "packageSurface") {
-		const resolvers = engine.registry.packageSurfaceResolvers();
-		if (resolvers.length === 0) {
-			throw new Error("packageSurface capability is not available");
-		}
-		const host = packageSurfaceHost(engine);
-		const packageKeys = new Set<string>();
-		const packageAccess = new Map<string, string>();
-		const paths = new Set<string>();
-		let filesVisited = 0;
-		let anyPackage = false;
-
-		for (const resolve of resolvers) {
-			signal.throwIfAborted();
-			const graph = await resolve(absolutePath, host, signal);
-			if (graph === undefined) continue;
-			anyPackage = true;
-			filesVisited += graph.filesVisited;
-			for (const key of graph.declKeys) packageKeys.add(key);
-			for (const [key, access] of graph.accessByDecl) packageAccess.set(key, access);
-			for (const path of graph.paths) paths.add(path);
-		}
-
-		if (!anyPackage) {
-			throw new Error("packageSurface: no package found for a supporting language near the scope path");
-		}
+	const resolvers = engine.registry.packageSurfaceResolvers();
+	if (resolvers.length === 0) {
+		throw new Error("packageSurface capability is not available");
+	}
+	const host = packageSurfaceHost(engine);
+	const packageKeys = new Set<string>();
+	const packageAccess = new Map<string, string>();
+	const paths = new Set<string>();
+	let filesVisited = 0;
+	let anyPackage = false;
+
+	for (const resolve of resolvers) {
+		signal.throwIfAborted();
+		const graph = await resolve(absolutePath, host, signal);
+		if (graph === undefined) continue;
+		anyPackage = true;
+		filesVisited += graph.filesVisited;
+		for (const key of graph.declKeys) packageKeys.add(key);
+		for (const [key, access] of graph.accessByDecl) packageAccess.set(key, access);
+		for (const path of graph.paths) paths.add(path);
+	}
 
-		for (const path of paths) {
-			signal.throwIfAborted();
-			if (bucket.workLimitReached) break;
-			const file = await engine.sourceForFile(path);
-			walkFileDecls(bucket, query, file, "packageSurface", packageKeys, packageAccess);
-		}
+	if (!anyPackage) {
+		throw new Error("packageSurface: no package found for a supporting language near the scope path");
+	}
 
-		const finalized = finalizeBucket(bucket, resultLimit);
-		return {
-			...finalized,
-			scan: {
-				limit: undefined,
-				filesVisited,
-				sourceBytes: 0,
-				elapsedMs: 0,
-				filesEmitted: paths.size,
-			},
-		};
+	const bucket = newBucket(query);
+	for (const path of paths) {
+		signal.throwIfAborted();
+		if (bucket.workLimitReached) break;
+		const file = await engine.sourceForFile(path);
+		walkFileDecls(bucket, query, file, "packageSurface", packageKeys, packageAccess);
 	}
 
+	return {
+		...finalizeBucket(bucket, resultLimit),
+		scan: {
+			limit: undefined,
+			filesVisited,
+			sourceBytes: 0,
+			elapsedMs: 0,
+			filesEmitted: paths.size,
+		},
+	};
+}
+
+async function discoverViaScan(
+	engine: ExploreEngine,
+	absolutePath: string,
+	query: DiscoverQuery,
+	surface: DiscoverSurface,
+	resultLimit: number,
+	signal: AbortSignal,
+): Promise<DiscoverResult> {
+	const bucket = newBucket(query);
 	const scan = scanSources({ engine, cwd: engine.cwd, root: absolutePath, signal });
 	let step = await scan.next();
 	let filesEmitted = 0;
@@ -421,7 +453,24 @@ export async function discover(
 				filesEmitted,
 			};
 	if (outcome.limit === "cancelled") throw new Error("discover cancelled");
+	return { ...finalizeBucket(bucket, resultLimit), scan: outcome };
+}
 
-	const finalized = finalizeBucket(bucket, resultLimit);
-	return { ...finalized, scan: outcome };
+/** Directory-scoped declaration discovery. Language rules stay on adapters. */
+export async function discover(
+	engine: ExploreEngine,
+	pathInput: string,
+	query: DiscoverQuery,
+	surface: DiscoverSurface,
+	resultLimit: number,
+	signal: AbortSignal,
+): Promise<DiscoverResult> {
+	signal.throwIfAborted();
+	const absolutePath = resolveExplorePath(engine.cwd, pathInput);
+	await pathIsDirectory(absolutePath, pathInput);
+
+	if (surface === "packageSurface") {
+		return discoverPackageSurface(engine, absolutePath, query, resultLimit, signal);
+	}
+	return discoverViaScan(engine, absolutePath, query, surface, resultLimit, signal);
 }