@shanepadgett/tau-agent 0.27.0 → 0.28.1

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

@@ -0,0 +1,175 @@
+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);
+};

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

@@ -0,0 +1,407 @@
+import type { Node, Tree } from "web-tree-sitter";
+import type { ExtractResult, GrammarAdapter, LanguageCapabilities } from "../adapter.ts";
+import { resolveOdinFileDep } from "./odin-file-deps.ts";
+import type { CallSite, Decl, ImportRef, Visibility } from "../ir.ts";
+import {
+	applyDoc,
+	callSite,
+	docSpanBefore,
+	endLine,
+	finishDecl,
+	qualify,
+	startLine,
+	unquote,
+	walkBodyNodes,
+	type DocSpan,
+} from "./tree.ts";
+
+const CAPABILITIES: LanguageCapabilities = {
+	shape: true,
+	search: true,
+	fileDeps: true,
+	callEdges: true,
+	packageSurface: false,
+};
+
+const IMPORT_NOISE = new Set([
+	"package",
+	"import",
+	"foreign",
+	"proc",
+	"where",
+	"when",
+	"if",
+	"else",
+	"for",
+	"in",
+	"switch",
+	"case",
+	"break",
+	"continue",
+	"fallthrough",
+	"return",
+	"defer",
+	"using",
+	"struct",
+	"union",
+	"enum",
+	"bit_set",
+	"map",
+	"dynamic",
+	"cast",
+	"transmute",
+	"auto_cast",
+	"true",
+	"false",
+	"nil",
+	"context",
+]);
+
+const EXTENSIONS = [".odin"] as const;
+
+/**
+ * Node kinds from tree-sitter-odin v1.3.0 node-types + locals.scm definitions:
+ *   procedure_declaration, overloaded_procedure_declaration → function
+ *   struct_declaration / union_declaration / bit_field_declaration → struct (union/bit_field closest kind)
+ *   enum_declaration → enum
+ *   const_declaration / const_type_declaration → constant
+ *   variable_declaration (`:=`) → variable, or function when value is `procedure`
+ *   var_declaration (`:`) → variable
+ *   field → struct field
+ *   foreign_block → walk nested package-level decls
+ * Package-level only (plan). Nested procs inside function bodies stay out.
+ */
+const PROCEDURE_DECLARATION = "procedure_declaration";
+const OVERLOADED_PROCEDURE_DECLARATION = "overloaded_procedure_declaration";
+const STRUCT_DECLARATION = "struct_declaration";
+const ENUM_DECLARATION = "enum_declaration";
+const UNION_DECLARATION = "union_declaration";
+const BIT_FIELD_DECLARATION = "bit_field_declaration";
+const CONST_DECLARATION = "const_declaration";
+const CONST_TYPE_DECLARATION = "const_type_declaration";
+const VAR_DECLARATION = "var_declaration";
+const VARIABLE_DECLARATION = "variable_declaration";
+const FOREIGN_BLOCK = "foreign_block";
+const IMPORT_DECLARATION = "import_declaration";
+const ATTRIBUTES = "attributes";
+const ATTRIBUTE = "attribute";
+const IDENTIFIER = "identifier";
+const PROCEDURE = "procedure";
+const FIELD = "field";
+const BLOCK = "block";
+
+const NESTED_SCOPE = new Set([
+	"procedure_declaration",
+	"overloaded_procedure_declaration",
+	"struct_declaration",
+	"enum_declaration",
+]);
+
+function extractCalls(body: Node | null): CallSite[] {
+	if (body === null) return [];
+	const out: CallSite[] = [];
+	walkBodyNodes(
+		body,
+		(n) => NESTED_SCOPE.has(n.type),
+		(node) => {
+			if (node.type !== "call_expression" && node.type !== "selector_call_expression") return;
+			const fn = node.childForFieldName("function") ?? node.namedChildren[0];
+			if (fn === null || fn === undefined) return;
+			let leafNode = fn;
+			let receiver = "";
+			if (fn.type === "member_expression" || fn.type === "selector_expression") {
+				const fieldNode = fn.childForFieldName("field") ?? fn.namedChildren[fn.namedChildren.length - 1];
+				const obj = fn.childForFieldName("argument") ?? fn.childForFieldName("operand") ?? fn.namedChildren[0];
+				if (fieldNode !== null && fieldNode !== undefined) leafNode = fieldNode;
+				if (obj !== null && obj !== undefined) receiver = obj.text;
+			}
+			const site = callSite(
+				leafNode.text,
+				startLine(leafNode),
+				leafNode.startIndex,
+				leafNode.endIndex,
+				"call",
+				receiver,
+			);
+			if (site !== undefined) out.push(site);
+		},
+	);
+	return out;
+}
+
+function odinDoc(node: Node, source: string): DocSpan | undefined {
+	return docSpanBefore(node, source);
+}
+
+function hasPrivateAttribute(node: Node): boolean {
+	const attrs = node.namedChildren.find((child) => child.type === ATTRIBUTES);
+	if (attrs === undefined) return false;
+	for (const attr of attrs.namedChildren) {
+		if (attr.type !== ATTRIBUTE) continue;
+		for (const child of attr.namedChildren) {
+			if (child.type === IDENTIFIER && child.text === "private") return true;
+		}
+	}
+	return false;
+}
+
+function visibilityOf(node: Node): Visibility {
+	return hasPrivateAttribute(node) ? "private" : "public";
+}
+
+/** First non-attribute identifier child — name position for all odin decls in this grammar. */
+function firstIdentifier(node: Node): string {
+	for (const child of node.namedChildren) {
+		if (child.type === ATTRIBUTES) continue;
+		if (child.type === IDENTIFIER) return child.text;
+	}
+	return "";
+}
+
+function procedureBody(node: Node): Node | null {
+	const proc = node.namedChildren.find((child) => child.type === PROCEDURE);
+	if (proc === undefined) return null;
+	// `---` foreign stubs use uninitialized, not block.
+	return proc.namedChildren.find((child) => child.type === BLOCK) ?? 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 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: [],
+		},
+		body,
+	);
+	if (body === null) decl.signatureEndOffset = node.endIndex;
+	return applyDoc(decl, doc);
+}
+
+/** struct_declaration children of type `field` (not `struct_field` — that is composite-literal elements). */
+function structFields(node: Node, owner: string): Decl[] {
+	const out: Decl[] = [];
+	for (const child of node.namedChildren) {
+		if (child.type !== FIELD) continue;
+		const names: string[] = [];
+		for (const part of child.namedChildren) {
+			if (part.type === IDENTIFIER) names.push(part.text);
+			if (part.type === "type") break;
+		}
+		for (const name of names) {
+			// `using _: T` embedding — skip blank identifier.
+			if (name === "_") continue;
+			const decl = leaf(child, owner, "field", name, "public", null, [], undefined);
+			if (decl !== undefined) out.push(decl);
+		}
+	}
+	return out;
+}
+
+function enumMembers(node: Node, owner: string): Decl[] {
+	const out: Decl[] = [];
+	let seenName = false;
+	for (const child of node.namedChildren) {
+		if (child.type !== IDENTIFIER) continue;
+		if (!seenName) {
+			seenName = true;
+			continue;
+		}
+		const decl = leaf(child, owner, "enumMember", child.text, "public", null, [], undefined);
+		if (decl !== undefined) out.push(decl);
+	}
+	return out;
+}
+
+/**
+ * bit_field_declaration flattens members as identifier/type/number triples after the backing type.
+ * Shape: Name :: bit_field Backing { field: T | bits, ... }
+ */
+function bitFieldMembers(node: Node, owner: string): Decl[] {
+	const out: Decl[] = [];
+	let seenName = false;
+	let seenBackingType = false;
+	for (const child of node.namedChildren) {
+		if (child.type === ATTRIBUTES) continue;
+		if (!seenName && child.type === IDENTIFIER) {
+			seenName = true;
+			continue;
+		}
+		if (seenName && !seenBackingType && child.type === "type") {
+			seenBackingType = true;
+			continue;
+		}
+		if (!seenBackingType) continue;
+		if (child.type === IDENTIFIER) {
+			const decl = leaf(child, owner, "field", child.text, "public", null, [], undefined);
+			if (decl !== undefined) out.push(decl);
+		}
+	}
+	return out;
+}
+
+function cutSignatureBefore(node: Node, firstChild: Node | undefined, decl: Decl): void {
+	if (firstChild === undefined) return;
+	decl.signatureEndOffset = firstChild.startIndex;
+	decl.bodyStartOffset = firstChild.startIndex;
+	decl.bodyEndOffset = node.endIndex;
+}
+
+function declsFromNode(node: Node, owner: string, source: string): Decl[] {
+	if (node.isError || node.type === "ERROR") {
+		const out: Decl[] = [];
+		for (const child of node.children) {
+			if (child.isNamed || child.isError) out.push(...declsFromNode(child, owner, source));
+		}
+		return out;
+	}
+
+	const doc = odinDoc(node, source);
+	const visibility = visibilityOf(node);
+
+	switch (node.type) {
+		case PROCEDURE_DECLARATION:
+		case OVERLOADED_PROCEDURE_DECLARATION: {
+			const name = firstIdentifier(node);
+			const body = node.type === PROCEDURE_DECLARATION ? procedureBody(node) : null;
+			const decl = leaf(node, owner, "function", name, visibility, body, [], doc);
+			return decl === undefined ? [] : [decl];
+		}
+		case STRUCT_DECLARATION: {
+			const name = firstIdentifier(node);
+			const qn = qualify(owner, name);
+			const children = structFields(node, qn);
+			const firstField = node.namedChildren.find((child) => child.type === FIELD);
+			const decl = leaf(node, owner, "struct", name, visibility, null, children, doc);
+			if (decl !== undefined) cutSignatureBefore(node, firstField, decl);
+			return decl === undefined ? [] : [decl];
+		}
+		case UNION_DECLARATION: {
+			// locals.scm: union → type; shared IR uses struct as closest kind.
+			const name = firstIdentifier(node);
+			const decl = leaf(node, owner, "struct", name, visibility, null, [], doc);
+			return decl === undefined ? [] : [decl];
+		}
+		case BIT_FIELD_DECLARATION: {
+			// locals.scm: bit_field → type; shared IR uses struct.
+			const name = firstIdentifier(node);
+			const qn = qualify(owner, name);
+			const children = bitFieldMembers(node, qn);
+			const decl = leaf(node, owner, "struct", name, visibility, null, children, doc);
+			// Signature through backing type: first member identifier after backing `type`.
+			const firstMember = children[0];
+			if (decl !== undefined && firstMember !== undefined) {
+				decl.signatureEndOffset = firstMember.startOffset;
+				decl.bodyStartOffset = firstMember.startOffset;
+				decl.bodyEndOffset = node.endIndex;
+			}
+			return decl === undefined ? [] : [decl];
+		}
+		case ENUM_DECLARATION: {
+			const name = firstIdentifier(node);
+			const qn = qualify(owner, name);
+			const children = enumMembers(node, qn);
+			const decl = leaf(node, owner, "enum", name, visibility, null, children, doc);
+			return decl === undefined ? [] : [decl];
+		}
+		case CONST_DECLARATION:
+		case CONST_TYPE_DECLARATION: {
+			// locals.scm: const_declaration → constant; const_type_declaration → type (value const with explicit type).
+			const name = firstIdentifier(node);
+			// `_ :: runtime` package aliases are not outline decls.
+			if (name === "_") return [];
+			const decl = leaf(node, owner, "constant", name, visibility, null, [], doc);
+			return decl === undefined ? [] : [decl];
+		}
+		case VAR_DECLARATION: {
+			// `name: Type` / `name: Type = value`
+			const name = firstIdentifier(node);
+			if (name === "_") return [];
+			const decl = leaf(node, owner, "variable", name, visibility, null, [], doc);
+			return decl === undefined ? [] : [decl];
+		}
+		case VARIABLE_DECLARATION: {
+			// `name := value` — function when value is a procedure literal (locals.scm still marks var).
+			const name = firstIdentifier(node);
+			if (name === "_") return [];
+			const proc = node.namedChildren.find((child) => child.type === PROCEDURE);
+			if (proc !== undefined) {
+				const body = proc.namedChildren.find((child) => child.type === BLOCK) ?? null;
+				const decl = leaf(node, owner, "function", name, visibility, body, [], doc);
+				return decl === undefined ? [] : [decl];
+			}
+			const decl = leaf(node, owner, "variable", name, visibility, null, [], doc);
+			return decl === undefined ? [] : [decl];
+		}
+		case FOREIGN_BLOCK: {
+			// Package-level foreign { ... } — extract nested decls at same owner.
+			const block = node.namedChildren.find((child) => child.type === BLOCK);
+			if (block === undefined) return [];
+			const out: Decl[] = [];
+			for (const child of block.namedChildren) {
+				out.push(...declsFromNode(child, owner, source));
+			}
+			return out;
+		}
+		default:
+			return [];
+	}
+}
+
+function collectImports(root: Node): ImportRef[] {
+	const imports: ImportRef[] = [];
+	for (const node of root.namedChildren) {
+		if (node.type !== IMPORT_DECLARATION) continue;
+		const str = node.namedChildren.find((child) => child.type === "string");
+		const specifier = str === undefined ? node.text : unquote(str.text);
+		imports.push({
+			specifier,
+			startLine: startLine(node),
+			startOffset: node.startIndex,
+			endOffset: node.endIndex,
+			bindings: [],
+		});
+	}
+	return imports;
+}
+
+function extractOdin(tree: Tree, source: string): ExtractResult {
+	const root = tree.rootNode;
+	const decls: Decl[] = [];
+	for (const node of root.children) {
+		if (node.isNamed || node.isError) decls.push(...declsFromNode(node, "", source));
+	}
+	return { decls, imports: collectImports(root) };
+}
+
+export function odinAdapter(): GrammarAdapter {
+	return {
+		mode: "grammar",
+		id: "odin",
+		extensions: EXTENSIONS,
+		capabilities: CAPABILITIES,
+		importNoiseIdentifiers: IMPORT_NOISE,
+		extract: extractOdin,
+		resolveFileDep: resolveOdinFileDep,
+	};
+}