@shanepadgett/tau-agent 0.26.0 → 0.28.0

package/extensions/explore/ast-worker.ts

@@ -1,356 +0,0 @@
-import { spawn, type ChildProcessWithoutNullStreams } from "node:child_process";
-import { existsSync } from "node:fs";
-import { join } from "node:path";
-import { fileURLToPath } from "node:url";
-
-export type AstLanguage =
-	| "typeScript"
-	| "tsx"
-	| "odin"
-	| "go"
-	| "rust"
-	| "cSharp"
-	| "java"
-	| "kotlin"
-	| "swift"
-	| "markdown";
-
-export type OutlineTarget = { kind: "file"; path: string; language: AstLanguage } | { kind: "directory"; path: string };
-
-export interface SourcePosition {
-	line: number;
-	column: number;
-}
-
-export interface SourceRange {
-	startByte: number;
-	endByte: number;
-	start: SourcePosition;
-	end: SourcePosition;
-}
-
-export interface OutlineEntry {
-	role: "item" | "member";
-	symbolType: string;
-	name: string;
-	qualifiedName: string;
-	range: SourceRange;
-	nameRange: SourceRange;
-	receiverRange?: SourceRange;
-	bodyRange?: SourceRange;
-	signature: string;
-	astKind: string;
-	certainty: "certain" | "recovered" | "nearRecovery";
-	certaintyReason?: string;
-	locator?: string;
-}
-
-export type SymbolView = "signature" | "declaration" | "declarationWithImports";
-
-export interface OutlineItem extends OutlineEntry {
-	rowKind: "package" | "import" | "declaration" | "export" | "sideEffect";
-	isImport: boolean;
-	isExported: boolean;
-	members: Array<OutlineEntry & { isPublic: boolean }>;
-}
-
-export interface OutlineFileResult {
-	path: string;
-	language: AstLanguage;
-	sourceFingerprint: string;
-	byteLength: number;
-	lineCount: number;
-	diagnostics: { errorNodes: number; missingNodes: number };
-	items: OutlineItem[];
-}
-
-export interface OutlineTargetResult {
-	path: string;
-	files: OutlineFileResult[];
-	totalByteLength: number;
-	totalLineCount: number;
-}
-
-export interface SymbolDeclaration {
-	locator: string;
-	path: string;
-	language: AstLanguage;
-	sourceFingerprint: string;
-	declarationRange: SourceRange;
-}
-
-export interface SymbolBlock {
-	path: string;
-	returnedRange: SourceRange;
-	declarationIndexes: number[];
-	source: string;
-}
-
-export interface SymbolBatchResult {
-	declarations: SymbolDeclaration[];
-	blocks: SymbolBlock[];
-}
-
-export interface AstClient {
-	getGeneration(): number;
-	outline(
-		target: OutlineTarget,
-		includePrivate: boolean,
-		includeDocs: boolean,
-		names: string[],
-		signal: AbortSignal | undefined,
-	): Promise<OutlineTargetResult>;
-	symbol(
-		locators: string[],
-		view: SymbolView,
-		contextLines: number,
-		signal: AbortSignal | undefined,
-	): Promise<SymbolBatchResult>;
-	shutdown(): Promise<void>;
-}
-
-type WorkerRequestPayload =
-	| { operation: "handshake" }
-	| { operation: "outline"; target: OutlineTarget; includePrivate: boolean; includeDocs: boolean; names: string[] }
-	| { operation: "symbol"; locators: string[]; view: SymbolView; contextLines: number };
-
-interface WorkerResponse {
-	requestId: number;
-	protocolVersion: number;
-	success: boolean;
-	result?: Record<string, unknown>;
-	error?: { code?: string; message?: string };
-}
-
-interface PendingRequest {
-	resolve(value: Record<string, unknown>): void;
-	reject(error: Error): void;
-	removeAbortListener(): void;
-}
-
-const PROTOCOL_VERSION = 5;
-const MAX_FRAME_BYTES = 8 * 1024 * 1024;
-const STDERR_BYTES = 16 * 1024;
-
-export type AstWorkerResolution = { command: string } | { error: Error };
-
-export function resolveAstWorkerCommand(
-	packageRoot: string,
-	platform: NodeJS.Platform,
-	arch: string,
-): AstWorkerResolution {
-	const packagedCommand = join(packageRoot, "native-bin", "darwin-arm64", "tau-ast");
-	if (platform === "darwin" && arch === "arm64" && existsSync(packagedCommand)) return { command: packagedCommand };
-
-	const sourceRoot = join(packageRoot, "native", "tau-ast");
-	if (existsSync(join(sourceRoot, "Cargo.toml")))
-		return { command: join(sourceRoot, "target", "release", `tau-ast${platform === "win32" ? ".exe" : ""}`) };
-
-	if (platform === "darwin" && arch === "arm64")
-		return {
-			error: new Error(
-				"tau-ast is missing from this @shanepadgett/tau-agent installation. Reinstall the package before using outline or symbol.",
-			),
-		};
-	return {
-		error: new Error(
-			`Packaged AST tools currently require an Apple Silicon Mac (darwin-arm64); this host is ${platform}-${arch}.`,
-		),
-	};
-}
-
-export class AstWorkerClient implements AstClient {
-	private readonly command: string | undefined;
-	private readonly args: readonly string[];
-	private child: ChildProcessWithoutNullStreams | undefined;
-	private startPromise: Promise<void> | undefined;
-	private pending = new Map<number, PendingRequest>();
-	private nextRequestId = 1;
-	private incoming = Buffer.alloc(0);
-	private stderr = "";
-	private generation = 0;
-
-	constructor(command: string | undefined = undefined, args: readonly string[] = []) {
-		this.command = command;
-		this.args = args;
-	}
-
-	getGeneration(): number {
-		return this.generation;
-	}
-
-	async outline(
-		target: OutlineTarget,
-		includePrivate: boolean,
-		includeDocs: boolean,
-		names: string[],
-		signal: AbortSignal | undefined,
-	): Promise<OutlineTargetResult> {
-		const result = await this.request({ operation: "outline", target, includePrivate, includeDocs, names }, signal);
-		if (result.kind !== "outline") throw new Error("tau-ast returned the wrong result for outline");
-		return result as unknown as OutlineTargetResult;
-	}
-
-	async symbol(
-		locators: string[],
-		view: SymbolView,
-		contextLines: number,
-		signal: AbortSignal | undefined,
-	): Promise<SymbolBatchResult> {
-		const result = await this.request({ operation: "symbol", locators, view, contextLines }, signal);
-		if (result.kind !== "symbol") throw new Error("tau-ast returned the wrong result for symbol");
-		return result as unknown as SymbolBatchResult;
-	}
-
-	async shutdown(): Promise<void> {
-		const child = this.child;
-		if (!child) return;
-		this.child = undefined;
-		this.startPromise = undefined;
-		this.rejectPending(new Error("tau-ast worker shut down"));
-		child.stdin.end();
-		if (child.exitCode !== null) return;
-		await Promise.race([
-			new Promise<void>((resolve) => child.once("exit", () => resolve())),
-			new Promise<void>((resolve) => setTimeout(resolve, 250)),
-		]);
-		if (child.exitCode === null) child.kill();
-	}
-
-	private async request(
-		request: WorkerRequestPayload,
-		signal: AbortSignal | undefined,
-	): Promise<Record<string, unknown>> {
-		await this.ensureStarted();
-		return this.send(request, signal);
-	}
-
-	private async ensureStarted(): Promise<void> {
-		if (this.startPromise) {
-			await this.startPromise;
-			return;
-		}
-		if (this.child) return;
-		this.startPromise ??= this.start().finally(() => {
-			this.startPromise = undefined;
-		});
-		await this.startPromise;
-	}
-
-	private async start(): Promise<void> {
-		const resolution = this.command
-			? { command: this.command }
-			: resolveAstWorkerCommand(fileURLToPath(new URL("../../", import.meta.url)), process.platform, process.arch);
-		if ("error" in resolution) throw resolution.error;
-		const child = spawn(resolution.command, this.args, { stdio: ["pipe", "pipe", "pipe"] });
-		this.generation += 1;
-		this.child = child;
-		this.incoming = Buffer.alloc(0);
-		this.stderr = "";
-		child.stdout.on("data", (chunk: Buffer) => this.receive(child, chunk));
-		child.stderr.on("data", (chunk: Buffer) => {
-			this.stderr = Buffer.from(`${this.stderr}${chunk.toString("utf8")}`)
-				.subarray(-STDERR_BYTES)
-				.toString("utf8");
-		});
-		child.on("error", (error) => this.fail(child, new Error(`Failed to start tau-ast: ${error.message}`)));
-		child.on("exit", (code, signal) => {
-			if (this.child !== child) return;
-			const suffix = this.stderr.trim() ? `: ${this.stderr.trim()}` : "";
-			this.fail(child, new Error(`tau-ast exited (${signal ?? code ?? "unknown"})${suffix}`), false);
-		});
-		try {
-			const result = await this.send({ operation: "handshake" }, undefined);
-			if (result.kind !== "handshake") throw new Error("tau-ast handshake returned the wrong result");
-		} catch (error) {
-			const failure = error instanceof Error ? error : new Error(String(error));
-			this.fail(child, failure);
-			throw failure;
-		}
-	}
-
-	private send(request: WorkerRequestPayload, signal: AbortSignal | undefined): Promise<Record<string, unknown>> {
-		const child = this.child;
-		if (!child) return Promise.reject(new Error("tau-ast worker is not running"));
-		if (signal?.aborted) return Promise.reject(new Error("tau-ast request cancelled"));
-		const requestId = this.nextRequestId++;
-		const payload = Buffer.from(JSON.stringify({ ...request, requestId, protocolVersion: PROTOCOL_VERSION }));
-		const frame = Buffer.allocUnsafe(payload.length + 4);
-		frame.writeUInt32BE(payload.length, 0);
-		payload.copy(frame, 4);
-
-		return new Promise<Record<string, unknown>>((resolve, reject) => {
-			const onAbort = (): void => this.fail(child, new Error("tau-ast request cancelled"));
-			signal?.addEventListener("abort", onAbort, { once: true });
-			this.pending.set(requestId, {
-				resolve,
-				reject,
-				removeAbortListener: () => signal?.removeEventListener("abort", onAbort),
-			});
-			child.stdin.write(frame, (error) => {
-				if (error) this.fail(child, new Error(`Failed to write tau-ast request: ${error.message}`));
-			});
-		});
-	}
-
-	private receive(child: ChildProcessWithoutNullStreams, chunk: Buffer): void {
-		if (this.child !== child) return;
-		this.incoming = Buffer.concat([this.incoming, chunk]);
-		while (this.incoming.length >= 4) {
-			const length = this.incoming.readUInt32BE(0);
-			if (length > MAX_FRAME_BYTES) {
-				this.fail(child, new Error(`tau-ast response frame exceeds ${MAX_FRAME_BYTES} bytes`));
-				return;
-			}
-			if (this.incoming.length < length + 4) return;
-			const payload = this.incoming.subarray(4, length + 4);
-			this.incoming = this.incoming.subarray(length + 4);
-			let response: WorkerResponse;
-			try {
-				response = JSON.parse(payload.toString("utf8")) as WorkerResponse;
-			} catch (error) {
-				this.fail(child, new Error(`tau-ast returned malformed JSON: ${String(error)}`));
-				return;
-			}
-			const pending = this.pending.get(response.requestId);
-			if (!pending) {
-				this.fail(child, new Error(`tau-ast returned unknown request id ${String(response.requestId)}`));
-				return;
-			}
-			this.pending.delete(response.requestId);
-			pending.removeAbortListener();
-			if (response.protocolVersion !== PROTOCOL_VERSION) {
-				const error = new Error(`tau-ast response used protocol ${response.protocolVersion}`);
-				pending.reject(error);
-				this.fail(child, error);
-				return;
-			}
-			if (!response.success) {
-				pending.reject(new Error(response.error?.message ?? response.error?.code ?? "tau-ast request failed"));
-				continue;
-			}
-			if (!response.result || typeof response.result !== "object") {
-				pending.reject(new Error("tau-ast response omitted its result"));
-				continue;
-			}
-			pending.resolve(response.result);
-		}
-	}
-
-	private fail(child: ChildProcessWithoutNullStreams, error: Error, kill = true): void {
-		if (this.child !== child) return;
-		this.child = undefined;
-		this.generation += 1;
-		this.incoming = Buffer.alloc(0);
-		this.rejectPending(error);
-		if (kill && child.exitCode === null) child.kill();
-	}
-
-	private rejectPending(error: Error): void {
-		for (const request of this.pending.values()) {
-			request.removeAbortListener();
-			request.reject(error);
-		}
-		this.pending.clear();
-	}
-}

package/extensions/explore/find.ts

@@ -1,147 +0,0 @@
-import { lstat } from "node:fs/promises";
-import { basename, matchesGlob } from "node:path";
-import { defineTool } from "@earendil-works/pi-coding-agent";
-import { Text } from "@earendil-works/pi-tui";
-import { type Static, Type } from "typebox";
-import { formatToolRowTitle, type ToolRowStateStore } from "../../shared/tool-row-state.js";
-import { divideBudget, normalizeCountLimit, normalizeNonNegativeInteger } from "./limits.ts";
-import {
-	formatPathForDisplay,
-	pathResolutionError,
-	relativeSlash,
-	resolveExplorePath,
-	stripLeadingAt,
-	toSlashPath,
-} from "./path-display.ts";
-import { type PathTreeEntry, renderPathTree } from "./path-tree.ts";
-import { createExploreTextResult, type ExploreTextDetails, expandedExploreText } from "./result.ts";
-import { collectPaths, type TraversalEntry } from "./traverse.ts";
-
-const findQueryParams = Type.Object(
-	{
-		path: Type.Optional(Type.String()),
-		patterns: Type.Optional(Type.Array(Type.String())),
-		type: Type.Optional(Type.Union([Type.Literal("file"), Type.Literal("dir"), Type.Literal("any")])),
-		maxDepth: Type.Optional(Type.Number()),
-		hidden: Type.Optional(Type.Boolean()),
-		noIgnore: Type.Optional(Type.Boolean()),
-	},
-	{ additionalProperties: false },
-);
-
-const findParams = Type.Object(
-	{
-		queries: Type.Array(findQueryParams, { minItems: 1 }),
-		limit: Type.Optional(Type.Number()),
-	},
-	{ additionalProperties: false },
-);
-
-type FindParams = Static<typeof findParams>;
-type FindQuery = Static<typeof findQueryParams>;
-
-function globMatches(pattern: string, value: string): boolean {
-	const normalizedValue = toSlashPath(value);
-	const normalizedPattern = toSlashPath(pattern);
-	return (
-		matchesGlob(normalizedValue, normalizedPattern) ||
-		(normalizedValue.startsWith(".") && matchesGlob(normalizedValue.slice(1), normalizedPattern))
-	);
-}
-
-function queryMatches(entry: TraversalEntry, queryRoot: string, query: FindQuery): boolean {
-	const type = query.type ?? "any";
-	if (type !== "any" && entry.type !== type) return false;
-	const patterns = query.patterns?.map(stripLeadingAt).filter((pattern) => pattern.length > 0) ?? [];
-	if (patterns.length === 0) return true;
-	const rel = relativeSlash(queryRoot, entry.absolutePath);
-	return patterns.some((pattern) => globMatches(pattern, pattern.includes("/") ? rel : basename(entry.displayPath)));
-}
-
-function toTreeEntry(entry: TraversalEntry): PathTreeEntry {
-	return { displayPath: entry.displayPath, type: entry.type };
-}
-
-function renderCallSummary(args: FindParams | undefined): string {
-	const queries = args?.queries ?? [];
-	const limit = normalizeCountLimit(args?.limit, 100);
-	if (queries.length !== 1) return `${queries.length} queries limit=${limit}`;
-	const query = queries[0];
-	const path = stripLeadingAt(query?.path ?? ".");
-	const patterns = query?.patterns?.map(stripLeadingAt).join(",") || "*";
-	const type = query?.type ?? "any";
-	const depth = query?.maxDepth === undefined ? "∞" : String(normalizeNonNegativeInteger(query.maxDepth, 0));
-	const flags = [query?.hidden ? "hidden" : "", query?.noIgnore ? "noIgnore" : ""].filter(Boolean).join(" ");
-	return `path=${path} patterns=${patterns} type=${type} depth=${depth} limit=${limit}${flags ? ` ${flags}` : ""}`;
-}
-
-export function createFindTool(rowState: ToolRowStateStore) {
-	return defineTool<typeof findParams, ExploreTextDetails | undefined>({
-		name: "find",
-		label: "find",
-		description: "Find files and directories by structured path queries.",
-		promptSnippet: "Find files and directories",
-		parameters: findParams,
-		async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
-			if (params.queries.length === 0) throw new Error("find requires at least one query");
-			const limit = normalizeCountLimit(params.limit, 100);
-			const budgets = divideBudget(limit, params.queries.length);
-			const humanParts: string[] = [];
-			const agentParts: string[] = [];
-
-			for (let i = 0; i < params.queries.length; i += 1) {
-				const query = params.queries[i];
-				if (!query) continue;
-				const inputPath = query.path ?? ".";
-				const root = resolveExplorePath(ctx.cwd, inputPath);
-				const rootStats = await lstat(root).catch((error: unknown) => {
-					throw pathResolutionError(error, inputPath);
-				});
-				const entries = await collectPaths({
-					cwd: ctx.cwd,
-					root,
-					maxDepth: query.maxDepth === undefined ? undefined : normalizeNonNegativeInteger(query.maxDepth, 0),
-					includeRoot: rootStats.isFile(),
-					includeHidden: query.hidden === true,
-					includeIgnored: query.noIgnore === true,
-					includeNoise: query.noIgnore === true,
-				}).catch((error: unknown) => {
-					throw new Error(`Query ${i + 1} failed: ${error instanceof Error ? error.message : String(error)}`);
-				});
-				const matches = entries.filter((entry) => queryMatches(entry, root, query));
-				const budget = budgets[i] ?? limit;
-				const shown = matches.slice(0, budget);
-				const omitted = matches.length - shown.length;
-				const notice = omitted > 0 ? `… omitted ${omitted} matches (limit ${budget})` : undefined;
-				const rootPath = formatPathForDisplay(root, ctx.cwd);
-				const tree =
-					shown.length > 0
-						? renderPathTree(shown.map(toTreeEntry), { rootPath, omissionNotice: notice })
-						: undefined;
-				const humanText = tree?.humanText ?? "No matches";
-				const agentText = tree?.agentText ?? "No matches";
-				if (params.queries.length === 1) {
-					humanParts.push(humanText);
-					agentParts.push(agentText);
-				} else {
-					humanParts.push(`query ${i + 1}\n${humanText}`);
-					agentParts.push(`q${i + 1}\n${agentText}`);
-				}
-			}
-
-			return createExploreTextResult(agentParts.join("\n"), humanParts.join("\n"));
-		},
-		renderCall(args, theme, context) {
-			rowState.watch(context.toolCallId, context.invalidate);
-			const text = (context.lastComponent as Text | undefined) ?? new Text("", 0, 0);
-			const title = formatToolRowTitle(rowState, context.toolCallId, "find", theme);
-			text.setText(`${title} ${theme.fg("muted", renderCallSummary(args))}`);
-			return text;
-		},
-		renderResult(result, _options, _theme, context) {
-			const text = (context.lastComponent as Text | undefined) ?? new Text("", 0, 0);
-			text.setText(context.expanded ? expandedExploreText(result) : "");
-			return text;
-		},
-	});
-}