@shanepadgett/tau-agent 0.27.0 → 0.28.1

package/extensions/explore/ast/languages/tree.ts

@@ -0,0 +1,220 @@
+import type { Node } from "web-tree-sitter";
+import type { CallSite, Decl } from "../ir.ts";
+
+export type DocSpan = {
+	docStartOffset: number;
+	docEndOffset: number;
+};
+
+export function startLine(node: Node): number {
+	return node.startPosition.row + 1;
+}
+
+export function endLine(node: Node): number {
+	const { row, column } = node.endPosition;
+	if (column === 0 && row > node.startPosition.row) return row;
+	return row + 1;
+}
+
+function newlineCount(source: string, from: number, to: number): number {
+	let count = 0;
+	const end = Math.min(to, source.length);
+	for (let i = Math.max(0, from); i < end; i += 1) {
+		if (source.charCodeAt(i) === 10) count += 1;
+	}
+	return count;
+}
+
+function isCommentType(type: string, commentTypes: readonly string[]): boolean {
+	return commentTypes.includes(type);
+}
+
+/**
+ * Contiguous leading comment siblings; ≤1 blank line between comments and before decl.
+ * `skipTypes` walks back through those sibling types first (e.g. TS decorators, Rust attributes).
+ * `commentTypes` defaults to tree-sitter `comment`; grammars that split line/block must pass their own.
+ */
+export function docSpanBefore(
+	node: Node,
+	source: string,
+	skipTypes: readonly string[] = [],
+	// Most grammars use `comment`; rust/java/kotlin pass their own line/block kinds.
+	commentTypes: readonly string[] = ["comment"],
+): DocSpan | undefined {
+	let cursor = node.previousSibling;
+	while (cursor !== null && skipTypes.includes(cursor.type)) {
+		cursor = cursor.previousSibling;
+	}
+	if (cursor === null || !isCommentType(cursor.type, commentTypes)) return undefined;
+	if (newlineCount(source, cursor.endIndex, node.startIndex) > 2) return undefined;
+
+	const docEndOffset = cursor.endIndex;
+	let docStartOffset = cursor.startIndex;
+	let gapRightStart = cursor.startIndex;
+
+	cursor = cursor.previousSibling;
+	while (cursor !== null && isCommentType(cursor.type, commentTypes)) {
+		if (newlineCount(source, cursor.endIndex, gapRightStart) > 2) break;
+		docStartOffset = cursor.startIndex;
+		gapRightStart = cursor.startIndex;
+		cursor = cursor.previousSibling;
+	}
+	return { docStartOffset, docEndOffset };
+}
+
+/**
+ * Trailing comment children of a preceding container (Kotlin package_header / import_list quirk).
+ * Same blank-line rule as sibling docs.
+ */
+export function docSpanTrailingChild(
+	container: Node,
+	before: Node,
+	source: string,
+	commentTypes: readonly string[],
+): DocSpan | undefined {
+	const named = container.namedChildren;
+	if (named.length === 0) return undefined;
+	const lastIndex = named.length - 1;
+	const lastComment = named[lastIndex];
+	if (lastComment === undefined || !isCommentType(lastComment.type, commentTypes)) return undefined;
+	if (newlineCount(source, lastComment.endIndex, before.startIndex) > 2) return undefined;
+
+	let firstIndex = lastIndex;
+	while (firstIndex - 1 >= 0) {
+		const prev = named[firstIndex - 1];
+		const current = named[firstIndex];
+		if (prev === undefined || current === undefined || !isCommentType(prev.type, commentTypes)) break;
+		if (newlineCount(source, prev.endIndex, current.startIndex) > 2) break;
+		firstIndex -= 1;
+	}
+	const first = named[firstIndex];
+	if (first === undefined) return undefined;
+	return { docStartOffset: first.startIndex, docEndOffset: lastComment.endIndex };
+}
+
+/** Expand decl start left through contiguous previous siblings of the given types (e.g. Rust attributes). */
+export function spanThroughPrevious(node: Node, types: readonly string[]): { startOffset: number; startLine: number } {
+	let startOffset = node.startIndex;
+	let line = startLine(node);
+	let cursor = node.previousSibling;
+	while (cursor !== null && types.includes(cursor.type)) {
+		startOffset = cursor.startIndex;
+		line = startLine(cursor);
+		cursor = cursor.previousSibling;
+	}
+	return { startOffset, startLine: line };
+}
+
+export function applyDoc(decl: Decl, doc: DocSpan | undefined): Decl {
+	if (doc === undefined) return decl;
+	return {
+		...decl,
+		docStartOffset: doc.docStartOffset,
+		docEndOffset: doc.docEndOffset,
+	};
+}
+
+export function unquote(text: string): string {
+	if (text.length < 2) return text;
+	const a = text[0];
+	const b = text[text.length - 1];
+	if ((a === '"' || a === "'" || a === "`") && a === b) return text.slice(1, -1);
+	return text;
+}
+
+export function field(node: Node, name: string): Node | null {
+	return node.childForFieldName(name);
+}
+
+export function nameText(node: Node | null | undefined): string {
+	if (node === null || node === undefined) return "";
+	return node.text;
+}
+
+export function qualify(owner: string, name: string): string {
+	return owner.length === 0 ? name : `${owner}.${name}`;
+}
+
+export type DeclDraft = Omit<Decl, "signatureEndOffset" | "children" | "calls" | "bases"> &
+	Partial<Pick<Decl, "signatureEndOffset" | "bodyStartOffset" | "bodyEndOffset" | "children" | "calls" | "bases">>;
+
+export function finishDecl(partial: DeclDraft, body: Node | null): Decl {
+	const calls = partial.calls ?? [];
+	const bases = partial.bases ?? [];
+	if (body === null) {
+		return {
+			...partial,
+			signatureEndOffset: partial.signatureEndOffset ?? partial.endOffset,
+			children: partial.children ?? [],
+			calls,
+			bases,
+		};
+	}
+	return {
+		...partial,
+		signatureEndOffset: body.startIndex,
+		bodyStartOffset: body.startIndex,
+		bodyEndOffset: body.endIndex,
+		children: partial.children ?? [],
+		calls,
+		bases,
+	};
+}
+
+/**
+ * Walk a body for call extraction. Skips nested scope roots (`isNestedScope`)
+ * so nested callables own their own sites.
+ */
+export function walkBodyNodes(body: Node, isNestedScope: (node: Node) => boolean, visit: (node: Node) => void): void {
+	const go = (node: Node, isRoot: boolean): void => {
+		if (!isRoot && isNestedScope(node)) return;
+		visit(node);
+		for (const child of node.namedChildren) go(child, false);
+	};
+	go(body, true);
+}
+
+export function callSite(
+	name: string,
+	line: number,
+	startOffset: number,
+	endOffset: number,
+	kind: CallSite["kind"],
+	receiver = "",
+): CallSite | undefined {
+	if (name.length === 0) return undefined;
+	return { name, receiver, line, startOffset, endOffset, kind };
+}
+
+/** Build a top-level-ish decl from a grammar node span + optional body. */
+export function declFromNode(
+	node: Node,
+	owner: string,
+	kind: Decl["kind"],
+	name: string,
+	exported: boolean,
+	body: Node | null,
+	children: Decl[],
+	doc: DocSpan | undefined,
+	visibility: Decl["visibility"] = "public",
+): Decl | undefined {
+	if (name.length === 0) return undefined;
+	return applyDoc(
+		finishDecl(
+			{
+				kind,
+				name,
+				qualifiedName: qualify(owner, name),
+				startLine: startLine(node),
+				endLine: endLine(node),
+				startOffset: node.startIndex,
+				endOffset: node.endIndex,
+				visibility,
+				exported,
+				children,
+			},
+			body,
+		),
+		doc,
+	);
+}

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

@@ -0,0 +1,259 @@
+import { readFile } from "node:fs/promises";
+import { dirname, extname, join, relative, resolve, sep } from "node:path";
+import type { FileDepHost, FileDepResolver } from "../adapter.ts";
+import {
+	externalId,
+	findAncestorFile,
+	firstExistingFile,
+	internalPaths,
+	isWithin,
+	packageNameFromBareSpecifier,
+} from "./file-dep-util.ts";
+
+const TS_SOURCE_EXTENSIONS = [".ts", ".tsx", ".mts", ".cts", ".mtsx"] as const;
+
+type TsPathMapping = {
+	pattern: string;
+	/** Directory paths are resolved against (configDir + baseUrl of defining tsconfig). */
+	baseDir: string;
+	targets: string[];
+};
+
+type TsPathsConfig = {
+	mappings: TsPathMapping[];
+};
+
+function pushTsStems(out: string[], stem: string): void {
+	for (const sourceExt of TS_SOURCE_EXTENSIONS) out.push(`${stem}${sourceExt}`);
+}
+
+function sourceCandidatesFromSeed(seed: string): string[] {
+	const out = [seed];
+	const ext = extname(seed);
+	if (ext === ".js" || ext === ".mjs" || ext === ".cjs" || ext === ".jsx") {
+		pushTsStems(out, seed.slice(0, -ext.length));
+		if (ext === ".jsx") out.push(`${seed.slice(0, -ext.length)}.tsx`);
+	} else if (seed.endsWith(".d.ts")) {
+		pushTsStems(out, seed.slice(0, -".d.ts".length));
+	} else if (ext === "") {
+		for (const sourceExt of TS_SOURCE_EXTENSIONS) {
+			out.push(`${seed}${sourceExt}`, join(seed, `index${sourceExt}`));
+		}
+	} else if (TS_SOURCE_EXTENSIONS.includes(ext as (typeof TS_SOURCE_EXTENSIONS)[number])) {
+		// already exact
+	} else {
+		pushTsStems(out, seed);
+		for (const sourceExt of TS_SOURCE_EXTENSIONS) out.push(join(seed, `index${sourceExt}`));
+	}
+	return out;
+}
+
+async function resolveExistingSource(host: FileDepHost, seed: string): Promise<string | undefined> {
+	const candidates = sourceCandidatesFromSeed(seed);
+	const preferred = candidates.filter((path) => {
+		if (path.endsWith(".d.ts")) return false;
+		const ext = extname(path);
+		return ext !== ".js" && ext !== ".mjs" && ext !== ".cjs" && ext !== ".jsx";
+	});
+	const hit = await firstExistingFile(host, preferred);
+	if (hit !== undefined) return hit;
+	return firstExistingFile(host, candidates);
+}
+
+async function resolveRelative(host: FileDepHost, baseDir: string, target: string): Promise<string | undefined> {
+	return resolveExistingSource(host, resolve(baseDir, target));
+}
+
+/**
+ * Enough JSONC for tsconfig: // line comments + trailing commas.
+ * Does not strip block comments with a regex — that eats path strings like `"./*"`.
+ */
+function parseJsonc(text: string): unknown {
+	const lines = text.split("\n").map((line) => {
+		let inString = false;
+		let escape = false;
+		for (let i = 0; i < line.length; i += 1) {
+			const ch = line.charAt(i);
+			if (escape) {
+				escape = false;
+				continue;
+			}
+			if (inString && ch === "\\") {
+				escape = true;
+				continue;
+			}
+			if (ch === '"') {
+				inString = !inString;
+				continue;
+			}
+			if (!inString && ch === "/" && line.charAt(i + 1) === "/") {
+				return line.slice(0, i);
+			}
+		}
+		return line;
+	});
+	const noTrail = lines.join("\n").replace(/,(\s*[}\]])/gu, "$1");
+	return JSON.parse(noTrail) as unknown;
+}
+
+function asRecord(value: unknown): Record<string, unknown> | undefined {
+	if (value === null || typeof value !== "object" || Array.isArray(value)) return undefined;
+	return value as Record<string, unknown>;
+}
+
+function readPathsObject(value: unknown): Record<string, string[]> {
+	const obj = asRecord(value);
+	if (obj === undefined) return {};
+	const out: Record<string, string[]> = {};
+	for (const [pattern, targets] of Object.entries(obj)) {
+		if (!Array.isArray(targets)) continue;
+		const list = targets.filter((t): t is string => typeof t === "string" && t.length > 0);
+		if (list.length > 0) out[pattern] = list;
+	}
+	return out;
+}
+
+/**
+ * Match `spec` against a TS paths pattern. Returns the `*` capture, or `""` for
+ * exact patterns, or undefined on no match.
+ */
+function matchPathPattern(pattern: string, spec: string): string | undefined {
+	const star = pattern.indexOf("*");
+	if (star === -1) return pattern === spec ? "" : undefined;
+	const prefix = pattern.slice(0, star);
+	const suffix = pattern.slice(star + 1);
+	if (!spec.startsWith(prefix) || !spec.endsWith(suffix)) return undefined;
+	if (spec.length < prefix.length + suffix.length) return undefined;
+	return spec.slice(prefix.length, spec.length - suffix.length);
+}
+
+function applyStar(target: string, capture: string): string {
+	const star = target.indexOf("*");
+	if (star === -1) return target;
+	return `${target.slice(0, star)}${capture}${target.slice(star + 1)}`;
+}
+
+async function loadTsconfigFile(path: string): Promise<Record<string, unknown> | undefined> {
+	let text: string;
+	try {
+		text = await readFile(path, "utf8");
+	} catch {
+		return undefined;
+	}
+	try {
+		return asRecord(parseJsonc(text));
+	} catch {
+		return undefined;
+	}
+}
+
+function resolveExtendsPath(fromConfig: string, extendsSpec: string): string {
+	const parentDir = dirname(fromConfig);
+	if (extendsSpec.endsWith(".json")) return resolve(parentDir, extendsSpec);
+	return resolve(parentDir, `${extendsSpec}.json`);
+}
+
+/**
+ * Nearest tsconfig/jsconfig paths + extends merge. Targets resolve against the
+ * defining config's directory + baseUrl (TypeScript rules).
+ */
+async function loadTsPathsConfig(
+	host: FileDepHost,
+	fromPath: string,
+	signal: AbortSignal,
+): Promise<TsPathsConfig | undefined> {
+	const startDir = dirname(fromPath);
+	const tsconfig =
+		(await findAncestorFile(host, startDir, host.scopeRoot, "tsconfig.json")) ??
+		(await findAncestorFile(host, startDir, host.scopeRoot, "jsconfig.json"));
+	if (tsconfig === undefined) return undefined;
+
+	const memoKey = `ts-paths:${tsconfig}`;
+	const cached = host.memo.get(memoKey);
+	if (cached !== undefined) return cached as TsPathsConfig;
+
+	// Root → leaf so leaf overrides.
+	const chain: string[] = [];
+	let current: string | undefined = tsconfig;
+	const seen = new Set<string>();
+	while (current !== undefined && !seen.has(current)) {
+		signal.throwIfAborted();
+		seen.add(current);
+		chain.push(current);
+		const json = await loadTsconfigFile(current);
+		if (json === undefined) break;
+		const ext = json.extends;
+		if (typeof ext !== "string" || ext.length === 0) break;
+		const parent = resolveExtendsPath(current, ext);
+		if (!isWithin(host.scopeRoot, parent) && resolve(parent) !== resolve(host.scopeRoot)) break;
+		current = parent;
+	}
+
+	const byPattern = new Map<string, TsPathMapping>();
+	for (const configPath of [...chain].reverse()) {
+		signal.throwIfAborted();
+		const json = await loadTsconfigFile(configPath);
+		if (json === undefined) continue;
+		const compiler = asRecord(json.compilerOptions);
+		if (compiler === undefined) continue;
+		const configDir = dirname(configPath);
+		const baseUrl = typeof compiler.baseUrl === "string" && compiler.baseUrl.length > 0 ? compiler.baseUrl : ".";
+		const baseDir = resolve(configDir, baseUrl);
+		const paths = readPathsObject(compiler.paths);
+		for (const [pattern, targets] of Object.entries(paths)) {
+			byPattern.set(pattern, { pattern, baseDir, targets });
+		}
+	}
+
+	const mappings = [...byPattern.values()].sort(
+		(a, b) => b.pattern.length - a.pattern.length || (a.pattern < b.pattern ? -1 : 1),
+	);
+	const config: TsPathsConfig = { mappings };
+	host.memo.set(memoKey, config);
+	return config;
+}
+
+async function resolveViaPaths(
+	host: FileDepHost,
+	fromPath: string,
+	specifier: string,
+	signal: AbortSignal,
+): Promise<string | undefined> {
+	const config = await loadTsPathsConfig(host, fromPath, signal);
+	if (config === undefined || config.mappings.length === 0) return undefined;
+
+	for (const mapping of config.mappings) {
+		signal.throwIfAborted();
+		const capture = matchPathPattern(mapping.pattern, specifier);
+		if (capture === undefined) continue;
+		for (const target of mapping.targets) {
+			const mapped = applyStar(target, capture);
+			// Guard obvious escapes outside scope after mapping.
+			const seed = resolve(mapping.baseDir, mapped);
+			const scopeRel = relative(resolve(host.scopeRoot), seed);
+			if (scopeRel.startsWith(`..${sep}`) || scopeRel === "..") continue;
+			const file = await resolveExistingSource(host, seed);
+			if (file !== undefined) return file;
+		}
+	}
+	return undefined;
+}
+
+export const resolveTypescriptFileDep: FileDepResolver = async (fromPath, specifier, host, signal) => {
+	signal.throwIfAborted();
+	const trimmed = specifier.trim();
+	if (trimmed.length === 0) return { kind: "unresolved" };
+	if (trimmed.startsWith("node:") || trimmed.startsWith("data:")) {
+		return externalId(packageNameFromBareSpecifier(trimmed));
+	}
+	if (trimmed.startsWith("./") || trimmed.startsWith("../")) {
+		const file = await resolveRelative(host, dirname(fromPath), trimmed);
+		if (file === undefined) return { kind: "unresolved" };
+		return internalPaths([file]);
+	}
+
+	const aliased = await resolveViaPaths(host, fromPath, trimmed, signal);
+	if (aliased !== undefined) return internalPaths([aliased]);
+
+	return externalId(packageNameFromBareSpecifier(trimmed));
+};