@shanepadgett/tau-agent 0.33.1 → 0.34.0

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

@@ -3,17 +3,15 @@ import type { ExtractResult, GrammarAdapter, LanguageCapabilities } from "../ada
 import { resolveCsharpFileDep } from "./csharp-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([
@@ -244,39 +243,7 @@ function bodyOf(node: Node): Node | null {
 	return field(node, "body") ?? field(node, "accessors") ?? field(node, "value");
 }
 
-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";
-	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 variableNames(declaration: Node | null): string[] {
 	if (declaration === null || declaration.type !== VARIABLE_DECLARATION) return [];
@@ -430,9 +397,11 @@ function collectImports(root: Node): ImportRef[] {
 	const imports: ImportRef[] = [];
 	for (const node of root.namedChildren) {
 		if (node.type !== USING_DIRECTIVE) continue;
-		// using X; / using static X; — take full directive text minus keyword noise via child names.
+		// using X; / using static X; / using Alias = X.Y; — the imported target is the
+		// last name child, so an alias name never masks what it points at.
 		const nameNode =
-			node.namedChildren.find((child) => child.type === "identifier" || child.type === "qualified_name") ?? null;
+			node.namedChildren.filter((child) => child.type === "identifier" || child.type === "qualified_name").at(-1) ??
+			null;
 		const specifier = nameNode === null ? node.text.replace(/^using\s+/, "").replace(/;$/, "") : nameNode.text;
 		imports.push({
 			specifier,
@@ -477,7 +446,7 @@ function extractCsharp(tree: Tree, source: string): ExtractResult {
 		}
 	}
 
-	return { decls, imports: collectImports(root) };
+	return { decls, imports: collectImports(root), fileCalls: extractCalls(root) };
 }
 
 export function csharpAdapter(): GrammarAdapter {

package/src/ast/languages/dotted-index.ts

@@ -0,0 +1,131 @@
+import { dirname, relative, resolve, sep } from "node:path";
+import type { FileDepHost } from "../adapter.ts";
+import { collectFilesWithExtensions, pickClosestPath, readTextFile } from "./file-dep-util.ts";
+
+/**
+ * Shared resolution index for dotted-namespace languages (C#, Java, Kotlin).
+ *
+ * Two lookups, both from one scan: a dotted type FQN → the file declaring it,
+ * and a dotted package → the directory holding it. Path-stem suffixes cover
+ * layouts where file name equals type name; declared-name keys cover the rest
+ * (Kotlin files whose name differs from their types, C# multi-type files).
+ */
+
+/** One declared type or top-level member, with the dotted package it sits in. */
+export type DeclaredName = { pkg: string; name: string };
+
+/** What a language pulls out of a file head. */
+export type HeadScan = { packages: string[]; names: DeclaredName[] };
+
+export type DottedIndex = {
+	/** slash key (path stems and `pkg/Name` FQNs) → files */
+	bySuffix: Map<string, string[]>;
+	/** package slash key → directories holding its files, plus that file count */
+	byPackage: Map<string, { dirs: string[]; fileCount: number }>;
+};
+
+/** Enough of a file to carry its package/namespace and top-level declarations. */
+const HEAD_CHARS = 12000;
+
+function slashKey(dotted: string): string {
+	return dotted.replace(/\./gu, "/");
+}
+
+function pushSuffix(map: Map<string, string[]>, key: string, file: string): void {
+	if (key.length === 0) return;
+	const list = map.get(key);
+	if (list === undefined) map.set(key, [file]);
+	else if (!list.includes(file)) list.push(file);
+}
+
+/** Index every slash-suffix of a stem path: a/b/c → a/b/c, b/c, c */
+function indexPathSuffixes(map: Map<string, string[]>, file: string, stemRelPosix: string): void {
+	const parts = stemRelPosix.split("/").filter((part) => part.length > 0);
+	for (let i = 0; i < parts.length; i += 1) {
+		pushSuffix(map, parts.slice(i).join("/"), file);
+	}
+}
+
+function toPosixRel(scopeRoot: string, file: string): string | undefined {
+	const rel = relative(resolve(scopeRoot), resolve(file));
+	if (rel.startsWith(`..${sep}`) || rel === ".." || rel.length === 0) return undefined;
+	return rel.split(sep).join("/");
+}
+
+export async function buildDottedIndex(
+	host: FileDepHost,
+	memoPrefix: string,
+	extensions: readonly string[],
+	scanHead: (head: string) => HeadScan,
+	signal: AbortSignal,
+): Promise<DottedIndex> {
+	const key = `${memoPrefix}:${host.scopeRoot}`;
+	const cached = host.memo.get(key);
+	if (cached !== undefined) return cached as DottedIndex;
+
+	const bySuffix = new Map<string, string[]>();
+	const byPackage = new Map<string, { dirs: string[]; fileCount: number }>();
+	const files = await collectFilesWithExtensions(host, host.scopeRoot, extensions, signal);
+
+	for (const file of files) {
+		signal.throwIfAborted();
+		const rel = toPosixRel(host.scopeRoot, file);
+		if (rel === undefined) continue;
+		const dot = rel.lastIndexOf(".");
+		indexPathSuffixes(bySuffix, file, dot >= 0 ? rel.slice(0, dot) : rel);
+
+		const text = await readTextFile(file);
+		if (text === undefined) continue;
+		const scan = scanHead(text.slice(0, HEAD_CHARS));
+		const packages = new Set(scan.packages);
+		for (const declared of scan.names) {
+			if (declared.pkg.length === 0 || declared.name.length === 0) continue;
+			packages.add(declared.pkg);
+			pushSuffix(bySuffix, `${slashKey(declared.pkg)}/${declared.name}`, file);
+		}
+		const dir = dirname(file);
+		for (const pkg of packages) {
+			if (pkg.length === 0) continue;
+			const entry = byPackage.get(slashKey(pkg));
+			if (entry === undefined) byPackage.set(slashKey(pkg), { dirs: [dir], fileCount: 1 });
+			else {
+				if (!entry.dirs.includes(dir)) entry.dirs.push(dir);
+				entry.fileCount += 1;
+			}
+		}
+	}
+
+	for (const [, list] of bySuffix) list.sort((a, b) => (a < b ? -1 : a > b ? 1 : 0));
+	const index: DottedIndex = { bySuffix, byPackage };
+	host.memo.set(key, index);
+	return index;
+}
+
+/** Dotted type FQN → declaring file, with a nested-type fallback to the outer type. */
+export function resolveDottedFile(index: DottedIndex, fromPath: string, dotted: string): string | undefined {
+	const key = slashKey(dotted);
+	const hit = pickClosestPath(index.bySuffix.get(key) ?? [], fromPath);
+	if (hit !== undefined) return hit;
+
+	// Nested type: Foo.Bar.Inner → try the Foo.Bar file.
+	const slash = key.lastIndexOf("/");
+	if (slash <= 0) return undefined;
+	return pickClosestPath(index.bySuffix.get(key.slice(0, slash)) ?? [], fromPath);
+}
+
+/**
+ * Dotted package → its directory. The importer's own directory is not an edge:
+ * same-directory files are visible without an import.
+ */
+export function resolveDottedPackage(
+	index: DottedIndex,
+	fromPath: string,
+	dotted: string,
+): { dir: string; fileCount: number } | undefined {
+	const entry = index.byPackage.get(slashKey(dotted));
+	if (entry === undefined) return undefined;
+	const dir = pickClosestPath(entry.dirs, fromPath);
+	if (dir === undefined) return undefined;
+	if (resolve(dir) === resolve(dirname(fromPath))) return undefined;
+	return { dir, fileCount: entry.fileCount };
+}

package/{extensions/explore → src}/ast/languages/file-dep-util.ts

@@ -17,19 +17,28 @@ export function externalId(id: string): FileDepResolution {
 	return { kind: "external", id };
 }
 
-/**
- * Prefer a short internal path list. Large fan-out becomes an external id so
- * namespace/package imports stay agent-usable instead of dumping whole trees.
- */
-export function boundedInternalPaths(
-	paths: readonly string[],
-	externalFallback: string,
-	maxFiles = 12,
-): FileDepResolution {
-	const unique = [...new Set(paths.map((path) => resolve(path)))].sort((a, b) => (a < b ? -1 : a > b ? 1 : 0));
-	if (unique.length === 0) return { kind: "unresolved" };
-	if (unique.length > maxFiles) return externalId(externalFallback);
-	return { kind: "internal", paths: unique };
+/** In-repo directory edge: a namespace/module/package import that would dump a whole tree. */
+export function packageDirectory(id: string, dir: string, fileCount: number): FileDepResolution {
+	return { kind: "package", id, dir: resolve(dir), fileCount };
+}
+
+/** Prefer the candidate sharing the most path prefix with the importer. */
+export function pickClosestPath(candidates: readonly string[], fromPath: string): string | undefined {
+	if (candidates.length <= 1) return candidates[0];
+	const fromSegs = resolve(fromPath).split(sep);
+	let best: string | undefined;
+	let bestCommon = -1;
+	for (const candidate of candidates) {
+		const segs = resolve(candidate).split(sep);
+		let common = 0;
+		const n = Math.min(fromSegs.length, segs.length);
+		while (common < n && fromSegs[common] === segs[common]) common += 1;
+		if (best === undefined || common > bestCommon || (common === bestCommon && candidate < best)) {
+			best = candidate;
+			bestCommon = common;
+		}
+	}
+	return best;
 }
 
 export async function firstExistingFile(host: FileDepHost, candidates: readonly string[]): Promise<string | undefined> {

package/src/ast/languages/fixtures/sample.cs

@@ -0,0 +1,53 @@
+using System;
+using System.Collections.Generic;
+
+namespace Demo;
+
+/// <summary>Greeter</summary>
+public class Greeter : IGreeter
+{
+	private int count;
+
+	public string Name { get; set; } = "";
+
+	public Greeter() {}
+
+	public Greeter(string name)
+	{
+		Name = name;
+	}
+
+	public void Hello()
+	{
+		count += 1;
+	}
+
+	public event EventHandler? Done;
+
+	public string this[int index] => Name;
+}
+
+internal struct Box
+{
+	public int Value;
+}
+
+public interface IGreeter
+{
+	void Hello();
+}
+
+public enum Color
+{
+	Red,
+	Green,
+}
+
+public record Person(string Name);
+
+public delegate void Notify(string message);
+
+static class Helpers
+{
+	public static IEnumerable<int> Range(int n) => System.Linq.Enumerable.Range(0, n);
+}

package/src/ast/languages/fixtures/sample.cs.expected.json

@@ -0,0 +1,156 @@
+{
+	"languageId": "c_sharp",
+	"parseDegraded": false,
+	"imports": [
+		"System",
+		"System.Collections.Generic"
+	],
+	"decls": [
+		{
+			"kind": "namespace",
+			"qualifiedName": "Demo",
+			"visibility": "public",
+			"exported": true,
+			"children": [
+				{
+					"kind": "class",
+					"qualifiedName": "Demo.Greeter",
+					"visibility": "public",
+					"exported": true,
+					"children": [
+						{
+							"kind": "field",
+							"qualifiedName": "Demo.Greeter.count",
+							"visibility": "private",
+							"exported": false,
+							"children": []
+						},
+						{
+							"kind": "property",
+							"qualifiedName": "Demo.Greeter.Name",
+							"visibility": "public",
+							"exported": true,
+							"children": []
+						},
+						{
+							"kind": "constructor",
+							"qualifiedName": "Demo.Greeter.Greeter",
+							"visibility": "public",
+							"exported": true,
+							"children": []
+						},
+						{
+							"kind": "constructor",
+							"qualifiedName": "Demo.Greeter.Greeter",
+							"visibility": "public",
+							"exported": true,
+							"children": []
+						},
+						{
+							"kind": "method",
+							"qualifiedName": "Demo.Greeter.Hello",
+							"visibility": "public",
+							"exported": true,
+							"children": []
+						},
+						{
+							"kind": "event",
+							"qualifiedName": "Demo.Greeter.Done",
+							"visibility": "public",
+							"exported": true,
+							"children": []
+						},
+						{
+							"kind": "property",
+							"qualifiedName": "Demo.Greeter.this",
+							"visibility": "public",
+							"exported": true,
+							"children": []
+						}
+					]
+				},
+				{
+					"kind": "struct",
+					"qualifiedName": "Demo.Box",
+					"visibility": "internal",
+					"exported": false,
+					"children": [
+						{
+							"kind": "field",
+							"qualifiedName": "Demo.Box.Value",
+							"visibility": "public",
+							"exported": true,
+							"children": []
+						}
+					]
+				},
+				{
+					"kind": "interface",
+					"qualifiedName": "Demo.IGreeter",
+					"visibility": "public",
+					"exported": true,
+					"children": [
+						{
+							"kind": "method",
+							"qualifiedName": "Demo.IGreeter.Hello",
+							"visibility": "public",
+							"exported": true,
+							"children": []
+						}
+					]
+				},
+				{
+					"kind": "enum",
+					"qualifiedName": "Demo.Color",
+					"visibility": "public",
+					"exported": true,
+					"children": [
+						{
+							"kind": "enumMember",
+							"qualifiedName": "Demo.Color.Red",
+							"visibility": "public",
+							"exported": true,
+							"children": []
+						},
+						{
+							"kind": "enumMember",
+							"qualifiedName": "Demo.Color.Green",
+							"visibility": "public",
+							"exported": true,
+							"children": []
+						}
+					]
+				},
+				{
+					"kind": "class",
+					"qualifiedName": "Demo.Person",
+					"visibility": "public",
+					"exported": true,
+					"children": []
+				},
+				{
+					"kind": "function",
+					"qualifiedName": "Demo.Notify",
+					"visibility": "public",
+					"exported": true,
+					"children": []
+				},
+				{
+					"kind": "class",
+					"qualifiedName": "Demo.Helpers",
+					"visibility": "internal",
+					"exported": false,
+					"children": [
+						{
+							"kind": "method",
+							"qualifiedName": "Demo.Helpers.Range",
+							"visibility": "public",
+							"exported": true,
+							"children": []
+						}
+					]
+				}
+			]
+		}
+	]
+}

package/src/ast/languages/fixtures/sample.go

@@ -0,0 +1,37 @@
+package demo
+
+import (
+	"fmt"
+	"io"
+)
+
+// Greeter greets callers.
+type Greeter struct {
+	Name string
+	count int
+}
+
+// Hello prints a greeting.
+func (g *Greeter) Hello() {
+	fmt.Println("hi", g.Name)
+}
+
+type Writer interface {
+	io.Writer
+	Flush() error
+}
+
+type Color int
+
+const (
+	Red Color = iota
+	Green
+)
+
+var DefaultName = "world"
+
+func NewGreeter(name string) *Greeter {
+	return &Greeter{Name: name}
+}
+
+func hidden() {}

package/src/ast/languages/fixtures/sample.go.expected.json

@@ -0,0 +1,96 @@
+{
+	"languageId": "go",
+	"parseDegraded": false,
+	"imports": [
+		"fmt",
+		"io"
+	],
+	"decls": [
+		{
+			"kind": "struct",
+			"qualifiedName": "Greeter",
+			"visibility": "public",
+			"exported": true,
+			"children": [
+				{
+					"kind": "field",
+					"qualifiedName": "Greeter.Name",
+					"visibility": "public",
+					"exported": true,
+					"children": []
+				},
+				{
+					"kind": "field",
+					"qualifiedName": "Greeter.count",
+					"visibility": "internal",
+					"exported": false,
+					"children": []
+				}
+			]
+		},
+		{
+			"kind": "method",
+			"qualifiedName": "Greeter.Hello",
+			"visibility": "public",
+			"exported": true,
+			"children": []
+		},
+		{
+			"kind": "interface",
+			"qualifiedName": "Writer",
+			"visibility": "public",
+			"exported": true,
+			"children": [
+				{
+					"kind": "method",
+					"qualifiedName": "Writer.Flush",
+					"visibility": "public",
+					"exported": true,
+					"children": []
+				}
+			]
+		},
+		{
+			"kind": "type",
+			"qualifiedName": "Color",
+			"visibility": "public",
+			"exported": true,
+			"children": []
+		},
+		{
+			"kind": "constant",
+			"qualifiedName": "Red",
+			"visibility": "public",
+			"exported": true,
+			"children": []
+		},
+		{
+			"kind": "constant",
+			"qualifiedName": "Green",
+			"visibility": "public",
+			"exported": true,
+			"children": []
+		},
+		{
+			"kind": "variable",
+			"qualifiedName": "DefaultName",
+			"visibility": "public",
+			"exported": true,
+			"children": []
+		},
+		{
+			"kind": "function",
+			"qualifiedName": "NewGreeter",
+			"visibility": "public",
+			"exported": true,
+			"children": []
+		},
+		{
+			"kind": "function",
+			"qualifiedName": "hidden",
+			"visibility": "internal",
+			"exported": false,
+			"children": []
+		}
+	]
+}

package/src/ast/languages/fixtures/sample.java

@@ -0,0 +1,40 @@
+package com.demo;
+
+import java.util.List;
+import java.util.ArrayList;
+
+/** Greeter type. */
+public class Greeter implements Named {
+	private int count;
+	public static final int MAX = 10;
+
+	public Greeter() {}
+
+	public Greeter(String name) {
+		this.count = name.length();
+	}
+
+	public void hello() {
+		count += 1;
+	}
+
+	@Override
+	public void name() {}
+}
+
+interface Named {
+	void name();
+}
+
+enum Color {
+	RED,
+	GREEN;
+
+	void paint() {}
+}
+
+record Point(int x, int y) {}
+
+@interface Internal {
+	String value() default "";
+}