@shanepadgett/tau-agent 0.33.1 → 0.34.0

package/extensions/explore/ast/languages/jvm-file-deps.ts

@@ -1,217 +0,0 @@
-import { dirname, join, relative, resolve, sep } from "node:path";
-import type { FileDepResolver } from "../adapter.ts";
-import { externalId, firstExistingFile, internalPaths, isWithin } from "./file-dep-util.ts";
-
-type JvmFileDepOptions = {
-	/** File extensions to match, e.g. .java / .kt */
-	extensions: readonly string[];
-	/** Leading packages always treated as external. */
-	externalPrefixes: readonly string[];
-	/** Extra source-root suffixes under scope (relative). */
-	sourceRootSuffixes: readonly string[];
-};
-
-function stripImportNoise(specifier: string): { path: string; wildcard: boolean } {
-	let s = specifier.trim().replace(/;$/u, "");
-	s = s.replace(/^static\s+/u, "");
-	const wildcard = s.endsWith(".*");
-	if (wildcard) {
-		// Keep full package path — do not peel segments (all-lowercase packages).
-		return { path: s.slice(0, -2).trim(), wildcard: true };
-	}
-	// Static/member imports: pkg.Type.member or pkg.Type.Companion.member → peel trailing
-	// non-type segments (lowercase start, or Companion/INSTANCE).
-	const parts = s.split(".").filter((part) => part.length > 0);
-	while (parts.length > 1) {
-		const last = parts[parts.length - 1];
-		if (last === undefined) break;
-		if (last === "Companion" || last === "INSTANCE" || last === "Default") {
-			parts.pop();
-			continue;
-		}
-		// Java/Kotlin type names are typically UpperCamel; members start lower.
-		const start = last.charAt(0);
-		if (start !== "" && start === start.toLowerCase() && start !== start.toUpperCase()) {
-			parts.pop();
-			continue;
-		}
-		break;
-	}
-	return { path: parts.join("."), wildcard: false };
-}
-
-function isExternalPackage(path: string, prefixes: readonly string[]): boolean {
-	for (const prefix of prefixes) {
-		if (path === prefix || path.startsWith(`${prefix}.`)) return true;
-	}
-	return false;
-}
-
-function segmentsOf(dotted: string): string[] {
-	return dotted.split(".").filter((part) => part.length > 0);
-}
-
-/** Infer source root by peeling package segments off dirname(fromPath). */
-function inferredSourceRoot(fromPath: string, packageSegments: readonly string[]): string | undefined {
-	if (packageSegments.length === 0) return dirname(fromPath);
-	const dir = resolve(dirname(fromPath));
-	const parts = dir.split(sep);
-	if (parts.length < packageSegments.length) return undefined;
-	const tail = parts.slice(parts.length - packageSegments.length);
-	if (tail.join("/") !== packageSegments.join("/") && tail.join(sep) !== packageSegments.join(sep)) {
-		// compare case-sensitive path segments
-		for (let i = 0; i < packageSegments.length; i += 1) {
-			if (tail[i] !== packageSegments[i]) return undefined;
-		}
-	}
-	return parts.slice(0, parts.length - packageSegments.length).join(sep) || sep;
-}
-
-/** Resolve a type import (`pkg.Type`) to 0–1 files under a source root. No package dumps. */
-async function resolveTypeAgainstRoot(
-	host: Parameters<FileDepResolver>[2],
-	sourceRoot: string,
-	segments: readonly string[],
-	extensions: readonly string[],
-): Promise<string | undefined> {
-	if (!isWithin(host.scopeRoot, sourceRoot) && resolve(sourceRoot) !== resolve(host.scopeRoot)) {
-		return undefined;
-	}
-	if (segments.length === 0) return undefined;
-	const typeName = segments[segments.length - 1];
-	const pkg = segments.slice(0, -1);
-	if (typeName === undefined) return undefined;
-	const dir = pkg.length === 0 ? sourceRoot : join(sourceRoot, ...pkg);
-	const candidates = extensions.map((ext) => join(dir, `${typeName}${ext}`));
-	const file = await firstExistingFile(host, candidates);
-	if (file !== undefined && isWithin(host.scopeRoot, file)) return file;
-	return undefined;
-}
-
-function sourceRootsFor(
-	host: Parameters<FileDepResolver>[2],
-	fromPath: string,
-	importSegments: readonly string[],
-	suffixes: readonly string[],
-): string[] {
-	const roots = new Set<string>();
-	// Peel one segment as possible type from fromPath package guess via path
-	const fromDir = dirname(fromPath);
-	const relToScope = relative(host.scopeRoot, fromDir);
-	if (!relToScope.startsWith("..") && !isAbsoluteRel(relToScope)) {
-		// try every ancestor as potential source root
-		const parts = relToScope.length === 0 ? [] : relToScope.split(sep);
-		for (let i = 0; i <= parts.length; i += 1) {
-			roots.add(i === 0 ? host.scopeRoot : join(host.scopeRoot, ...parts.slice(0, i)));
-		}
-	}
-	const inferred = inferredSourceRoot(fromPath, guessPackageSegments(fromPath, host.scopeRoot));
-	if (inferred !== undefined) roots.add(inferred);
-
-	for (const suffix of suffixes) {
-		roots.add(join(host.scopeRoot, ...suffix.split("/").filter((p) => p.length > 0)));
-	}
-
-	// Prefer roots that could contain the import path
-	void importSegments;
-	return [...roots];
-}
-
-function isAbsoluteRel(rel: string): boolean {
-	return rel.length > 0 && (rel.startsWith(sep) || /^[A-Za-z]:[\\/]/u.test(rel));
-}
-
-function guessPackageSegments(fromPath: string, scopeRoot: string): string[] {
-	const rel = relative(scopeRoot, dirname(fromPath));
-	if (rel.startsWith("..") || rel.length === 0) return [];
-	const parts = rel.split(sep);
-	// Drop common source root prefixes
-	const dropPrefixes = [
-		["src", "main", "java"],
-		["src", "main", "kotlin"],
-		["src", "commonMain", "kotlin"],
-		["src", "commonMain", "java"],
-		["src", "jvmMain", "kotlin"],
-		["src", "test", "java"],
-		["src", "test", "kotlin"],
-		["src"],
-	];
-	for (const prefix of dropPrefixes) {
-		if (parts.length >= prefix.length && prefix.every((p, i) => parts[i] === p)) {
-			return parts.slice(prefix.length);
-		}
-	}
-	// guava layout: guava/src/com/...
-	const comAt = parts.indexOf("com");
-	const orgAt = parts.indexOf("org");
-	const netAt = parts.indexOf("net");
-	const idx = [comAt, orgAt, netAt].filter((v) => v >= 0).sort((a, b) => a - b)[0];
-	if (idx !== undefined) return parts.slice(idx);
-	return parts;
-}
-
-function createJvmFileDepResolver(options: JvmFileDepOptions): FileDepResolver {
-	return async (fromPath, specifier, host, signal) => {
-		signal.throwIfAborted();
-		const raw = specifier
-			.trim()
-			.replace(/;$/u, "")
-			.replace(/^static\s+/u, "");
-		const { path, wildcard } = stripImportNoise(specifier);
-		if (path.length === 0) return { kind: "unresolved" };
-		if (isExternalPackage(path, options.externalPrefixes)) return externalId(path);
-
-		// Wildcards / bare packages are package ids — never dump every file in the dir.
-		if (wildcard) return externalId(path);
-
-		const segments = segmentsOf(path);
-		const packageOnly =
-			segments.length > 0 &&
-			segments.every((seg) => {
-				const c = seg.charAt(0);
-				return c === c.toLowerCase() && c !== c.toUpperCase();
-			});
-		// Top-level function/property import (okio.buffer) peels to package-only segments.
-		const rawParts = raw
-			.replace(/\.\*$/u, "")
-			.split(".")
-			.filter((part) => part.length > 0);
-		const lastRaw = rawParts[rawParts.length - 1];
-		const memberLike =
-			lastRaw !== undefined &&
-			lastRaw !== "Companion" &&
-			lastRaw.charAt(0) === lastRaw.charAt(0).toLowerCase() &&
-			lastRaw.charAt(0) !== lastRaw.charAt(0).toUpperCase();
-		if (packageOnly) {
-			return externalId(memberLike ? raw.replace(/\.\*$/u, "") : path);
-		}
-
-		const roots = sourceRootsFor(host, fromPath, segments, options.sourceRootSuffixes);
-		for (const root of roots) {
-			signal.throwIfAborted();
-			const file = await resolveTypeAgainstRoot(host, root, segments, options.extensions);
-			if (file !== undefined) return internalPaths([file]);
-		}
-		return externalId(path);
-	};
-}
-
-export const resolveJavaFileDep = createJvmFileDepResolver({
-	extensions: [".java"],
-	externalPrefixes: ["java", "javax", "jakarta", "jdk", "sun"],
-	sourceRootSuffixes: ["src/main/java", "src"],
-});
-
-export const resolveKotlinFileDep = createJvmFileDepResolver({
-	// .kts is often Gradle — not a package type file.
-	extensions: [".kt", ".java"],
-	externalPrefixes: ["java", "javax", "jakarta", "kotlin", "kotlinx"],
-	sourceRootSuffixes: [
-		"src/main/kotlin",
-		"src/main/java",
-		"src/commonMain/kotlin",
-		"src/commonMain/java",
-		"src/jvmMain/kotlin",
-		"src",
-	],
-});

package/extensions/explore/ast/languages/odin-file-deps.ts

@@ -1,175 +0,0 @@
-import { dirname, join, resolve } from "node:path";
-import type { FileDepHost, FileDepResolver } from "../adapter.ts";
-import { boundedInternalPaths, externalId, firstExistingFile, internalPaths, isWithin } from "./file-dep-util.ts";
-
-/** `collection:pkg/path` — Odin collection import. */
-const COLLECTION_SPEC = /^([A-Za-z_][A-Za-z0-9_]*):(.+)$/u;
-
-async function isDir(host: FileDepHost, path: string): Promise<boolean> {
-	if (!(await host.pathExists(path))) return false;
-	if (await host.isFile(path)) return false;
-	return true;
-}
-
-/** Direct `.odin` package files in a directory (not nested packages). */
-async function listOdinPackageFiles(host: FileDepHost, dir: string): Promise<string[]> {
-	if (!(await isDir(host, dir))) return [];
-	const names = await host.readDir(dir);
-	const out: string[] = [];
-	for (const name of names) {
-		if (!name.endsWith(".odin")) continue;
-		const full = join(dir, name);
-		if ((await host.isFile(full)) && host.ownsPath(full)) out.push(full);
-	}
-	return out;
-}
-
-/**
- * Odin root under scope: directory that has both `core` and `base` collections.
- * Also accepts ODIN_ROOT when that path sits inside the scope.
- */
-async function findOdinRoot(host: FileDepHost, fromPath: string): Promise<string | undefined> {
-	const key = `odin-root:${host.scopeRoot}`;
-	if (host.memo.has(key)) return host.memo.get(key) as string | undefined;
-
-	const envRoot = process.env.ODIN_ROOT?.trim();
-	if (envRoot !== undefined && envRoot.length > 0) {
-		const absolute = resolve(envRoot);
-		if (isWithin(host.scopeRoot, absolute) || absolute === resolve(host.scopeRoot)) {
-			if ((await isDir(host, join(absolute, "core"))) && (await isDir(host, join(absolute, "base")))) {
-				host.memo.set(key, absolute);
-				return absolute;
-			}
-		}
-	}
-
-	let dir = resolve(dirname(fromPath));
-	const stop = resolve(host.scopeRoot);
-	for (;;) {
-		if (isWithin(stop, dir) || dir === stop) {
-			const core = join(dir, "core");
-			const base = join(dir, "base");
-			if ((await isDir(host, core)) && (await isDir(host, base))) {
-				host.memo.set(key, dir);
-				return dir;
-			}
-		}
-		if (dir === stop) break;
-		const parent = dirname(dir);
-		if (parent === dir) break;
-		if (!isWithin(stop, parent) && parent !== stop) break;
-		dir = parent;
-	}
-
-	// Scope itself may be the Odin tree root even when fromPath walk missed.
-	const scopeCore = join(stop, "core");
-	const scopeBase = join(stop, "base");
-	if ((await isDir(host, scopeCore)) && (await isDir(host, scopeBase))) {
-		host.memo.set(key, stop);
-		return stop;
-	}
-
-	host.memo.set(key, undefined);
-	return undefined;
-}
-
-/**
- * Candidate roots for a named collection, nearest-first.
- * Project `vendor`/`shared` beside sources beat the compiler tree when both exist.
- */
-async function collectionRoots(host: FileDepHost, collection: string, fromPath: string): Promise<string[]> {
-	const key = `odin-collection:${host.scopeRoot}:${collection}`;
-	const cached = host.memo.get(key);
-	if (cached !== undefined) return cached as string[];
-
-	const found: string[] = [];
-	const seen = new Set<string>();
-	const add = async (candidate: string) => {
-		const absolute = resolve(candidate);
-		if (seen.has(absolute)) return;
-		if (!isWithin(host.scopeRoot, absolute) && absolute !== resolve(host.scopeRoot)) return;
-		if (!(await isDir(host, absolute))) return;
-		seen.add(absolute);
-		found.push(absolute);
-	};
-
-	// Ancestors from the importing file up to scope (project-local collections).
-	let dir = resolve(dirname(fromPath));
-	const stop = resolve(host.scopeRoot);
-	for (;;) {
-		await add(join(dir, collection));
-		if (dir === stop) break;
-		const parent = dirname(dir);
-		if (parent === dir) break;
-		if (!isWithin(stop, parent) && parent !== stop) break;
-		dir = parent;
-	}
-
-	await add(join(stop, collection));
-
-	const odinRoot = await findOdinRoot(host, fromPath);
-	if (odinRoot !== undefined) await add(join(odinRoot, collection));
-
-	host.memo.set(key, found);
-	return found;
-}
-
-async function resolveCollectionImport(
-	host: FileDepHost,
-	collection: string,
-	pkgPath: string,
-	fromPath: string,
-	signal: AbortSignal,
-): Promise<ReturnType<typeof internalPaths> | ReturnType<typeof externalId>> {
-	const id = `${collection}:${pkgPath}`;
-	const segments = pkgPath.split(/[/\\]/u).filter((part) => part.length > 0 && part !== "." && part !== "..");
-	if (segments.length === 0) return externalId(id);
-
-	const roots = await collectionRoots(host, collection, fromPath);
-	for (const root of roots) {
-		signal.throwIfAborted();
-		const dir = join(root, ...segments);
-		if (!isWithin(host.scopeRoot, dir) && dir !== resolve(host.scopeRoot)) continue;
-		const files = await listOdinPackageFiles(host, dir);
-		// Fat packages (e.g. base:runtime) stay package-id edges, not 40+ file dumps.
-		if (files.length > 0) return boundedInternalPaths(files, id);
-	}
-	return externalId(id);
-}
-
-async function resolveRelativeImport(
-	host: FileDepHost,
-	fromPath: string,
-	trimmed: string,
-): Promise<ReturnType<typeof internalPaths> | { kind: "unresolved" }> {
-	const absolute = resolve(dirname(fromPath), trimmed);
-	const candidates = [absolute, `${absolute}.odin`, join(absolute, "main.odin")];
-	const file = await firstExistingFile(host, candidates);
-	if (file !== undefined && isWithin(host.scopeRoot, file)) return internalPaths([file]);
-
-	const files = (await listOdinPackageFiles(host, absolute)).filter((path) => isWithin(host.scopeRoot, path));
-	if (files.length > 0) return boundedInternalPaths(files, trimmed);
-	return { kind: "unresolved" };
-}
-
-export const resolveOdinFileDep: FileDepResolver = async (fromPath, specifier, host, signal) => {
-	signal.throwIfAborted();
-	const trimmed = specifier.trim().replace(/^"+|"+$/gu, "");
-	if (trimmed.length === 0) return { kind: "unresolved" };
-
-	const collection = COLLECTION_SPEC.exec(trimmed);
-	if (collection !== null) {
-		const name = collection[1];
-		const pkg = collection[2];
-		if (name === undefined || pkg === undefined) return { kind: "unresolved" };
-		return resolveCollectionImport(host, name, pkg, fromPath, signal);
-	}
-
-	// Relative / path-like package path
-	if (trimmed.startsWith("./") || trimmed.startsWith("../") || trimmed.includes("/") || trimmed.includes("\\")) {
-		return resolveRelativeImport(host, fromPath, trimmed);
-	}
-
-	// Bare name with no collection — cannot resolve without collection config.
-	return externalId(trimmed);
-};