@shanepadgett/tau-agent 0.33.1 → 0.34.0

package/src/ast/languages/jvm-file-deps.ts

@@ -0,0 +1,135 @@
+import { resolve } from "node:path";
+import type { FileDepResolver } from "../adapter.ts";
+import { buildDottedIndex, resolveDottedFile, resolveDottedPackage, type HeadScan } from "./dotted-index.ts";
+import { externalId, internalPaths, isWithin, packageDirectory } from "./file-dep-util.ts";
+
+/**
+ * Java / Kotlin file deps. Real multi-module builds put module B's sources
+ * anywhere, so resolution goes through a package-path index rather than a fixed
+ * list of source-root suffixes: a type import resolves to the declaring file, a
+ * wildcard or top-level member import to the package directory.
+ */
+
+type JvmFileDepOptions = {
+	/** File extensions to match, e.g. .java / .kt */
+	extensions: readonly string[];
+	/** Leading packages always treated as external. */
+	externalPrefixes: readonly string[];
+	/** Top-level declaration keywords, in this language's syntax. */
+	declarationPattern: RegExp;
+	memoPrefix: string;
+};
+
+const PACKAGE_LINE = /^[ \t]*package\s+([\w.]+)\s*;?[ \t]*$/mu;
+
+function scanJvmHead(head: string, declarationPattern: RegExp): HeadScan {
+	const pkg = PACKAGE_LINE.exec(head)?.[1] ?? "";
+	if (pkg.length === 0) return { packages: [], names: [] };
+	const names: HeadScan["names"] = [];
+	// Fresh lastIndex per scan: the pattern is shared across files.
+	const pattern = new RegExp(declarationPattern.source, declarationPattern.flags);
+	for (const match of head.matchAll(pattern)) {
+		const name = match[2];
+		if (name !== undefined) names.push({ pkg, name });
+	}
+	return { packages: [pkg], names };
+}
+
+function startsLower(text: string): boolean {
+	const first = text.charAt(0);
+	return first.length > 0 && first === first.toLowerCase() && first !== first.toUpperCase();
+}
+
+/**
+ * Split an import into the dotted path plus how it should resolve.
+ * Package segments are lowercase and type segments capitalized, so the first
+ * capitalized segment ends a type import; an import with none names a package
+ * member (Kotlin top-level fun/val) and resolves to the package.
+ */
+function classifyImport(specifier: string): { path: string; packageLike: boolean } {
+	let s = specifier.trim().replace(/;$/u, "");
+	s = s.replace(/^static\s+/u, "");
+	if (s.endsWith(".*")) {
+		// Keep the full package path — do not peel segments (all-lowercase packages).
+		return { path: s.slice(0, -2).trim(), packageLike: true };
+	}
+	const parts = s.split(".").filter((part) => part.length > 0);
+	const typeAt = parts.findIndex((part) => !startsLower(part));
+	// pkg.Type.member / pkg.Type.Companion.member all resolve through pkg.Type.
+	if (typeAt >= 0) return { path: parts.slice(0, typeAt + 1).join("."), packageLike: false };
+	if (parts.length <= 1) return { path: parts.join("."), packageLike: false };
+	return { path: parts.slice(0, -1).join("."), packageLike: true };
+}
+
+function isExternalPackage(path: string, prefixes: readonly string[]): boolean {
+	for (const prefix of prefixes) {
+		if (path === prefix || path.startsWith(`${prefix}.`)) return true;
+	}
+	return false;
+}
+
+function createJvmFileDepResolver(options: JvmFileDepOptions): FileDepResolver {
+	return async (fromPath, specifier, host, signal) => {
+		signal.throwIfAborted();
+		const { path, packageLike } = classifyImport(specifier);
+		if (path.length === 0) return { kind: "unresolved" };
+		if (isExternalPackage(path, options.externalPrefixes)) return externalId(path);
+
+		const index = await buildDottedIndex(
+			host,
+			options.memoPrefix,
+			options.extensions,
+			(head) => scanJvmHead(head, options.declarationPattern),
+			signal,
+		);
+
+		if (packageLike) {
+			const pkg = resolveDottedPackage(index, fromPath, path);
+			if (pkg === undefined || !isWithin(host.scopeRoot, pkg.dir)) return externalId(path);
+			return packageDirectory(path, pkg.dir, pkg.fileCount);
+		}
+
+		const file = resolveDottedFile(index, fromPath, path);
+		if (file !== undefined && isWithin(host.scopeRoot, file) && host.ownsPath(file)) {
+			if (resolve(file) === resolve(fromPath)) return { kind: "unresolved" };
+			return internalPaths([file]);
+		}
+		// No declaring file, but the package may still be in the repo: generated
+		// sources (Android `R`, Apollo fragments) and declarations below the head
+		// window land here, and the package they live in is the real dependency.
+		const owningPackage = path.split(".").slice(0, -1).join(".");
+		const pkg = owningPackage.length === 0 ? undefined : resolveDottedPackage(index, fromPath, owningPackage);
+		if (pkg === undefined || !isWithin(host.scopeRoot, pkg.dir)) return externalId(path);
+		return packageDirectory(owningPackage, pkg.dir, pkg.fileCount);
+	};
+}
+
+const MODIFIERS =
+	"public|protected|private|static|final|abstract|sealed|non-sealed|strictfp|default|internal|open|data|value|annotation|enum|expect|actual|external|inline|suspend|const|lateinit|companion|operator|infix|tailrec";
+
+/** `@Anno`s and modifiers, then the keyword and the declared name. */
+const JAVA_DECLARATION = new RegExp(
+	`^[ \\t]*(?:@[\\w.]+(?:\\([^)]*\\))?[ \\t]*)*(?:(?:${MODIFIERS})[ \\t]+)*(class|interface|enum|record|@interface)\\s+([A-Za-z_]\\w*)`,
+	"gmu",
+);
+
+/** Kotlin also indexes top-level fun/val/typealias; the optional dotted part is an extension receiver. */
+const KOTLIN_DECLARATION = new RegExp(
+	`^[ \\t]*(?:@[\\w.]+(?:\\([^)]*\\))?[ \\t]*)*(?:(?:${MODIFIERS})[ \\t]+)*(class|interface|object|fun|val|var|typealias)\\s+(?:<[^>]*>\\s+)?(?:[A-Za-z_][\\w.]*\\.)?([A-Za-z_]\\w*)`,
+	"gmu",
+);
+
+export const resolveJavaFileDep = createJvmFileDepResolver({
+	extensions: [".java"],
+	externalPrefixes: ["java", "javax", "jakarta", "jdk", "sun"],
+	declarationPattern: JAVA_DECLARATION,
+	memoPrefix: "java-dotted",
+});
+
+export const resolveKotlinFileDep = createJvmFileDepResolver({
+	// .kts is often Gradle — not a package type file.
+	extensions: [".kt", ".java"],
+	externalPrefixes: ["java", "javax", "jakarta", "kotlin", "kotlinx"],
+	declarationPattern: KOTLIN_DECLARATION,
+	memoPrefix: "kotlin-dotted",
+});

package/{extensions/explore → src}/ast/languages/kotlin.ts

@@ -3,17 +3,15 @@ import type { ExtractResult, GrammarAdapter, LanguageCapabilities } from "../ada
 import { resolveKotlinFileDep } from "./jvm-file-deps.ts";
 import type { CallSite, Decl, ImportRef, Visibility } from "../ir.ts";
 import {
-	applyDoc,
 	callSite,
+	type DocSpan,
 	docSpanBefore,
 	docSpanTrailingChild,
-	endLine,
-	finishDecl,
+	createLeafBuilder,
 	nameText,
 	qualify,
 	startLine,
 	walkBodyNodes,
-	type DocSpan,
 } from "./tree.ts";
 
 const CAPABILITIES: LanguageCapabilities = {
@@ -22,6 +20,7 @@ const CAPABILITIES: LanguageCapabilities = {
 	fileDeps: true,
 	callEdges: true,
 	packageSurface: false,
+	structuralImplements: false,
 };
 
 const IMPORT_NOISE = new Set([
@@ -282,40 +281,7 @@ function functionBody(node: Node): Node | null {
 	return body ?? null;
 }
 
-function leaf(
-	node: Node,
-	owner: string,
-	kind: Decl["kind"],
-	name: string,
-	visibility: Visibility,
-	body: Node | null,
-	children: Decl[],
-	doc: DocSpan | undefined,
-): Decl | undefined {
-	if (name.length === 0) return undefined;
-	const callable = kind === "function" || kind === "method" || kind === "constructor";
-	const typeLike =
-		kind === "class" || kind === "interface" || kind === "enum" || kind === "struct" || kind === "object";
-	const decl = finishDecl(
-		{
-			kind,
-			name,
-			qualifiedName: qualify(owner, name),
-			startLine: startLine(node),
-			endLine: endLine(node),
-			startOffset: node.startIndex,
-			endOffset: node.endIndex,
-			visibility,
-			exported: visibility === "public" || visibility === "internal",
-			children,
-			calls: callable ? extractCalls(body) : [],
-			bases: typeLike ? heritageBases(node) : [],
-		},
-		body,
-	);
-	if (body === null) decl.signatureEndOffset = node.endIndex;
-	return applyDoc(decl, doc);
-}
+const leaf = createLeafBuilder(extractCalls, heritageBases);
 
 function primaryConstructorProperties(ctor: Node, owner: string): Decl[] {
 	const out: Decl[] = [];
@@ -595,7 +561,7 @@ function extractKotlin(tree: Tree, source: string): ExtractResult {
 	for (const node of root.children) {
 		if (node.isNamed || node.isError) decls.push(...declsFromNode(node, "", source));
 	}
-	return { decls: rehomeOrphanMembers(decls), imports: collectImports(root) };
+	return { decls: rehomeOrphanMembers(decls), imports: collectImports(root), fileCalls: extractCalls(root) };
 }
 
 export function kotlinAdapter(): GrammarAdapter {

package/{extensions/explore → src}/ast/languages/rust-file-deps.ts

@@ -27,9 +27,9 @@ async function resolveModuleChain(
 		const candidates = await moduleFileCandidates(dir, name);
 		const file = await firstExistingFile(host, candidates);
 		if (file === undefined) {
-			// Last segment may be an item in the parent module — keep parent file.
-			if (i === segments.length - 1 && lastFile !== undefined) return lastFile;
-			return undefined;
+			// Remaining segments are items inside the deepest module that exists
+			// (inline `mod`, re-export, cfg-gated shim). Never drop the edge silently.
+			return lastFile;
 		}
 		lastFile = file;
 		// Next modules live beside foo.rs → foo/ or inside foo/ for mod.rs

package/{extensions/explore → src}/ast/languages/rust.ts

@@ -23,6 +23,7 @@ const CAPABILITIES: LanguageCapabilities = {
 	fileDeps: true,
 	callEdges: true,
 	packageSurface: false,
+	structuralImplements: false,
 };
 
 const IMPORT_NOISE = new Set([
@@ -393,32 +394,39 @@ function declsFromItem(
 			return decl === undefined ? [] : [decl];
 		}
 		case IMPL_ITEM: {
-			// Methods become siblings under the target type name (inherent + trait impls).
 			const target = rustTypeName(field(node, "type"));
 			const body = field(node, "body");
 			if (body === null || body.type !== DECLARATION_LIST || target.length === 0) return [];
 			const methodOwner = owner.length === 0 ? target : qualify(owner, target);
 			const methods = walkDeclList(body, owner, source, methodOwner, true);
-			// Marker decl so `implementations Trait` finds this impl via bases (trait name).
 			const trait = rustTypeName(field(node, "trait"));
-			if (trait.length === 0) return methods;
-			const marker = finishDecl(
+			// The impl block is the container its methods belong to: named for what it
+			// is, so it never shadows the target type, and holding its own methods.
+			const name = trait.length === 0 ? `impl ${target}` : `impl ${trait} for ${target}`;
+			// An impl block carries no visibility modifier; its surface is its methods'.
+			const visibility: Visibility = methods.some((method) => method.visibility === "public")
+				? "public"
+				: methods.some((method) => method.visibility === "internal")
+					? "internal"
+					: "private";
+			const container = finishDecl(
 				{
 					kind: "class",
-					name: target,
-					qualifiedName: methodOwner,
+					name,
+					qualifiedName: name,
 					startLine: node.startPosition.row + 1,
 					endLine: endLine(node),
 					startOffset: node.startIndex,
 					endOffset: node.endIndex,
-					visibility: "public",
-					exported: true,
-					children: [],
-					bases: [trait],
+					visibility,
+					exported: rustExported(visibility),
+					children: methods,
+					// `implementations Trait` finds this impl through the trait base.
+					bases: trait.length === 0 ? [] : [trait],
 				},
-				null,
+				body,
 			);
-			return [marker, ...methods];
+			return [applyDoc(container, doc)];
 		}
 		case MOD_ITEM: {
 			const name = nameText(field(node, "name"));
@@ -490,7 +498,7 @@ function extractRust(tree: Tree, source: string): ExtractResult {
 	}
 	const imports: ImportRef[] = [];
 	collectImports(root, imports);
-	return { decls, imports };
+	return { decls, imports, fileCalls: extractCalls(root) };
 }
 
 export function rustAdapter(): GrammarAdapter {

package/{extensions/explore → src}/ast/languages/swift-file-deps.ts

@@ -1,6 +1,12 @@
-import { basename, join, resolve } from "node:path";
+import { join, resolve, sep } from "node:path";
 import type { FileDepResolver } from "../adapter.ts";
-import { collectFilesWithExtensions, externalId, internalPaths, isWithin } from "./file-dep-util.ts";
+import {
+	collectFilesWithExtensions,
+	externalId,
+	isWithin,
+	packageDirectory,
+	pickClosestPath,
+} from "./file-dep-util.ts";
 
 async function findModuleDirs(
 	host: Parameters<FileDepResolver>[2],
@@ -37,23 +43,24 @@ async function findModuleDirs(
 	return hits;
 }
 
-export const resolveSwiftFileDep: FileDepResolver = async (_fromPath, specifier, host, signal) => {
+/**
+ * `import SomeModule` names a module, not a file list: expanding it to every
+ * file in the module directory made `deps` and `impact` unusable on real corpora.
+ * One package edge for the module directory instead.
+ */
+export const resolveSwiftFileDep: FileDepResolver = async (fromPath, specifier, host, signal) => {
 	signal.throwIfAborted();
 	const moduleName = specifier.trim().split(/\s+/u)[0] ?? "";
 	if (moduleName.length === 0) return { kind: "unresolved" };
 
 	// Skip obvious system modules when no local dir exists — still try local first.
 	const dirs = await findModuleDirs(host, moduleName, signal);
-	const files: string[] = [];
-	for (const dir of dirs) {
-		if (!isWithin(host.scopeRoot, dir)) continue;
-		const found = await collectFilesWithExtensions(host, dir, [".swift"], signal, 500);
-		for (const file of found) {
-			// Don't treat the module root listing as importing itself only — include all.
-			if (basename(file) === moduleName) continue;
-			files.push(file);
-		}
-	}
-	if (files.length === 0) return externalId(moduleName);
-	return internalPaths(files);
+	const inScope = dirs.filter((dir) => isWithin(host.scopeRoot, dir));
+	const dir = pickClosestPath(inScope, fromPath);
+	if (dir === undefined) return externalId(moduleName);
+	const files = await collectFilesWithExtensions(host, dir, [".swift"], signal, 500);
+	// Package.swift is the manifest, not module source.
+	const sources = files.filter((file) => !file.endsWith(`${sep}Package.swift`));
+	if (sources.length === 0) return externalId(moduleName);
+	return packageDirectory(moduleName, dir, sources.length);
 };

package/{extensions/explore → src}/ast/languages/swift.ts

@@ -3,17 +3,15 @@ import type { ExtractResult, GrammarAdapter, LanguageCapabilities } from "../ada
 import { resolveSwiftFileDep } from "./swift-file-deps.ts";
 import type { CallSite, Decl, ImportRef, Visibility } from "../ir.ts";
 import {
-	applyDoc,
 	callSite,
+	type DocSpan,
 	docSpanBefore,
-	endLine,
 	field,
-	finishDecl,
+	createLeafBuilder,
 	nameText,
 	qualify,
 	startLine,
 	walkBodyNodes,
-	type DocSpan,
 } from "./tree.ts";
 
 const CAPABILITIES: LanguageCapabilities = {
@@ -22,6 +20,7 @@ const CAPABILITIES: LanguageCapabilities = {
 	fileDeps: true,
 	callEdges: true,
 	packageSurface: false,
+	structuralImplements: false,
 };
 
 const IMPORT_NOISE = new Set([
@@ -242,40 +241,7 @@ function bodyOf(node: Node): Node | null {
 	);
 }
 
-function leaf(
-	node: Node,
-	owner: string,
-	kind: Decl["kind"],
-	name: string,
-	visibility: Visibility,
-	body: Node | null,
-	children: Decl[],
-	doc: DocSpan | undefined,
-): Decl | undefined {
-	if (name.length === 0) return undefined;
-	const callable = kind === "function" || kind === "method" || kind === "constructor";
-	const typeLike =
-		kind === "class" || kind === "interface" || kind === "enum" || kind === "struct" || kind === "object";
-	const decl = finishDecl(
-		{
-			kind,
-			name,
-			qualifiedName: qualify(owner, name),
-			startLine: startLine(node),
-			endLine: endLine(node),
-			startOffset: node.startIndex,
-			endOffset: node.endIndex,
-			visibility,
-			exported: visibility === "public",
-			children,
-			calls: callable ? extractCalls(body) : [],
-			bases: typeLike ? heritageBases(node) : [],
-		},
-		body,
-	);
-	if (body === null) decl.signatureEndOffset = node.endIndex;
-	return applyDoc(decl, doc);
-}
+const leaf = createLeafBuilder(extractCalls, heritageBases);
 
 function classKind(kindText: string): Decl["kind"] {
 	if (kindText === "struct") return "struct";
@@ -450,7 +416,11 @@ function extractSwift(tree: Tree, source: string): ExtractResult {
 		}
 		decls.push(...declsFromNode(node, "", source));
 	}
-	return { decls: mergeExtensionMembers(decls, extensions), imports: collectImports(root) };
+	return {
+		decls: mergeExtensionMembers(decls, extensions),
+		imports: collectImports(root),
+		fileCalls: extractCalls(root),
+	};
 }
 
 export function swiftAdapter(): GrammarAdapter {

package/{extensions/explore → src}/ast/languages/tree.ts

@@ -186,6 +186,53 @@ export function callSite(
 	return { name, receiver, line, startOffset, endOffset, kind };
 }
 
+const CALLABLE_KINDS = new Set<Decl["kind"]>(["function", "method", "constructor"]);
+const TYPE_LIKE_KINDS = new Set<Decl["kind"]>(["class", "interface", "enum", "struct", "object"]);
+
+export type LeafBuilder = (
+	node: Node,
+	owner: string,
+	kind: Decl["kind"],
+	name: string,
+	visibility: Decl["visibility"],
+	body: Node | null,
+	children: Decl[],
+	doc: DocSpan | undefined,
+) => Decl | undefined;
+
+/**
+ * Builds one leaf decl per grammar adapter: calls come from callable bodies,
+ * bases from type-like heritage, and the span closes on the signature when the
+ * node has no body.
+ */
+export function createLeafBuilder(
+	extractCalls: (body: Node | null) => CallSite[],
+	heritageBases: (node: Node) => string[],
+): LeafBuilder {
+	return (node, owner, kind, name, visibility, body, children, doc) => {
+		if (name.length === 0) return undefined;
+		const decl = finishDecl(
+			{
+				kind,
+				name,
+				qualifiedName: qualify(owner, name),
+				startLine: startLine(node),
+				endLine: endLine(node),
+				startOffset: node.startIndex,
+				endOffset: node.endIndex,
+				visibility,
+				exported: visibility === "public",
+				children,
+				calls: CALLABLE_KINDS.has(kind) ? extractCalls(body) : [],
+				bases: TYPE_LIKE_KINDS.has(kind) ? heritageBases(node) : [],
+			},
+			body,
+		);
+		if (body === null) decl.signatureEndOffset = node.endIndex;
+		return applyDoc(decl, doc);
+	};
+}
+
 /** Build a top-level-ish decl from a grammar node span + optional body. */
 export function declFromNode(
 	node: Node,

package/{extensions/explore → src}/ast/languages/typescript-file-deps.ts

@@ -239,6 +239,111 @@ async function resolveViaPaths(
 	return undefined;
 }
 
+/** package name → package root, from the scope root's npm workspaces globs. */
+type WorkspaceMap = Map<string, string>;
+
+async function readManifest(path: string): Promise<Record<string, unknown> | undefined> {
+	const json = await loadTsconfigFile(path);
+	return json;
+}
+
+function workspaceGlobs(manifest: Record<string, unknown>): string[] {
+	const value = manifest.workspaces;
+	if (Array.isArray(value)) return value.filter((entry): entry is string => typeof entry === "string");
+	const packages = asRecord(value)?.packages;
+	if (Array.isArray(packages)) return packages.filter((entry): entry is string => typeof entry === "string");
+	return [];
+}
+
+/**
+ * Workspace packages resolve through an npm symlink the resolver must not follow:
+ * a `/node_modules/` path fails `host.ownsPath` and would duplicate the real file.
+ * Expand the globs against the scope root instead.
+ */
+async function loadWorkspacePackages(host: FileDepHost, signal: AbortSignal): Promise<WorkspaceMap> {
+	const key = `ts-workspaces:${host.scopeRoot}`;
+	const cached = host.memo.get(key);
+	if (cached !== undefined) return cached as WorkspaceMap;
+
+	const map: WorkspaceMap = new Map();
+	const root = await readManifest(join(host.scopeRoot, "package.json"));
+	for (const glob of root === undefined ? [] : workspaceGlobs(root)) {
+		signal.throwIfAborted();
+		const star = glob.indexOf("*");
+		const dirs: string[] = [];
+		if (star === -1) {
+			dirs.push(resolve(host.scopeRoot, glob));
+		} else {
+			const parent = resolve(host.scopeRoot, glob.slice(0, star).replace(/\/$/u, ""));
+			for (const name of await host.readDir(parent)) {
+				if (name.startsWith(".")) continue;
+				dirs.push(join(parent, name));
+			}
+		}
+		for (const dir of dirs) {
+			const manifest = await readManifest(join(dir, "package.json"));
+			const name = manifest?.name;
+			if (typeof name === "string" && name.length > 0) map.set(name, dir);
+		}
+	}
+
+	host.memo.set(key, map);
+	return map;
+}
+
+function entryTargets(manifest: Record<string, unknown>): string[] {
+	const out: string[] = [];
+	const exports = manifest.exports;
+	if (typeof exports === "string") out.push(exports);
+	const dot = asRecord(exports)?.["."];
+	if (typeof dot === "string") out.push(dot);
+	const conditions = asRecord(dot);
+	if (conditions !== undefined) {
+		for (const field of ["types", "import", "module", "default"] as const) {
+			const value = conditions[field];
+			if (typeof value === "string") out.push(value);
+		}
+	}
+	for (const field of ["types", "module", "main"] as const) {
+		const value = manifest[field];
+		if (typeof value === "string") out.push(value);
+	}
+	out.push("src/index.ts", "index.ts");
+	return out;
+}
+
+async function resolveWorkspacePackage(
+	host: FileDepHost,
+	specifier: string,
+	signal: AbortSignal,
+): Promise<string | undefined> {
+	const workspaces = await loadWorkspacePackages(host, signal);
+	if (workspaces.size === 0) return undefined;
+
+	let matched: { name: string; dir: string } | undefined;
+	for (const [name, dir] of workspaces) {
+		if (specifier !== name && !specifier.startsWith(`${name}/`)) continue;
+		if (matched === undefined || name.length > matched.name.length) matched = { name, dir };
+	}
+	if (matched === undefined) return undefined;
+
+	if (specifier.length > matched.name.length) {
+		const subpath = specifier.slice(matched.name.length + 1);
+		return (
+			(await resolveExistingSource(host, resolve(matched.dir, subpath))) ??
+			(await resolveExistingSource(host, resolve(matched.dir, "src", subpath)))
+		);
+	}
+
+	const manifest = await readManifest(join(matched.dir, "package.json"));
+	if (manifest === undefined) return undefined;
+	for (const target of entryTargets(manifest)) {
+		const file = await resolveExistingSource(host, resolve(matched.dir, target));
+		if (file !== undefined) return file;
+	}
+	return undefined;
+}
+
 export const resolveTypescriptFileDep: FileDepResolver = async (fromPath, specifier, host, signal) => {
 	signal.throwIfAborted();
 	const trimmed = specifier.trim();
@@ -255,5 +360,8 @@ export const resolveTypescriptFileDep: FileDepResolver = async (fromPath, specif
 	const aliased = await resolveViaPaths(host, fromPath, trimmed, signal);
 	if (aliased !== undefined) return internalPaths([aliased]);
 
+	const workspace = await resolveWorkspacePackage(host, trimmed, signal);
+	if (workspace !== undefined && isWithin(host.scopeRoot, workspace)) return internalPaths([workspace]);
+
 	return externalId(packageNameFromBareSpecifier(trimmed));
 };

package/{extensions/explore → src}/ast/languages/typescript-package-surface.ts

@@ -3,7 +3,7 @@ import { dirname, extname, isAbsolute, join, relative, resolve, sep } from "node
 import type { Decl } from "../ir.ts";
 import type { FileSource } from "../engine.ts";
 import { packageDeclKey, type PackageSurfaceHost, type PackageSurfaceResolver } from "../package-surface.ts";
-import { formatPathForDisplay } from "../../traverse.ts";
+import { formatPathForDisplay } from "../traverse.ts";
 
 const RE_EXPORT_DEPTH = 4;
 const TS_SOURCE_EXTENSIONS = [".ts", ".tsx", ".mts", ".cts", ".mtsx"] as const;
@@ -40,6 +40,7 @@ async function fileExists(path: string): Promise<boolean> {
 async function findPackageJson(startDir: string, stopDir: string): Promise<string | undefined> {
 	let dir = resolve(startDir);
 	const stop = resolve(stopDir);
+	const bounded = isWithin(stop, dir);
 	for (;;) {
 		const candidate = join(dir, "package.json");
 		try {
@@ -47,10 +48,10 @@ async function findPackageJson(startDir: string, stopDir: string): Promise<strin
 		} catch {
 			// walk up
 		}
-		if (dir === stop) return undefined;
+		if (bounded && dir === stop) return undefined;
 		const parent = dirname(dir);
 		if (parent === dir) return undefined;
-		if (!isWithin(stop, parent) && parent !== stop) return undefined;
+		if (bounded && !isWithin(stop, parent) && parent !== stop) return undefined;
 		dir = parent;
 	}
 }

package/{extensions/explore → src}/ast/languages/typescript.ts

@@ -25,6 +25,7 @@ const CAPABILITIES: LanguageCapabilities = {
 	fileDeps: true,
 	callEdges: true,
 	packageSurface: true,
+	structuralImplements: false,
 };
 
 /** Keywords/types skipped when matching imports to a decl slice. */
@@ -153,10 +154,7 @@ const EXPORT_SPECIFIER = "export_specifier";
 
 const NESTED_CALLABLE = new Set([
 	FUNCTION_DECLARATION,
-	FUNCTION_EXPRESSION,
 	GENERATOR_FUNCTION_DECLARATION,
-	ARROW_FUNCTION,
-	METHOD_DEFINITION,
 	CLASS_DECLARATION,
 	ABSTRACT_CLASS_DECLARATION,
 	CLASS,
@@ -548,7 +546,7 @@ function variableDecls(node: Node, owner: string, exported: boolean, doc: DocSpa
 				endOffset: spanNode.endIndex,
 				visibility: "public",
 				exported,
-				calls: isFn ? extractCalls(body) : [],
+				calls: isFn ? extractCalls(body) : value === null ? [] : extractCalls(value),
 			},
 			body,
 		);
@@ -725,7 +723,7 @@ function extractTypeScript(tree: Tree, source: string): ExtractResult {
 	const decls = walkStatementList(top, "", source, false);
 	const imports: ImportRef[] = [];
 	collectImportsFrom(root, imports);
-	return { decls, imports };
+	return { decls, imports, fileCalls: extractCalls(root) };
 }
 
 function makeAdapter(id: "typescript" | "tsx", extensions: readonly string[]): GrammarAdapter {