@oh-my-pi/pi-tui 18.4.2 → 18.4.4

package/src/tools/grouped-file-output.ts

@@ -1,6 +1,11 @@
 import * as path from "node:path";
 
 import { buildPathTree, isUrlLikePath, type PathTreeInput, walkPathTree } from "@oh-my-pi/pi-utils";
+import type { TspTone } from "@oh-my-pi/pi-wire";
+import { code, col, keyed, span, text } from "../native/describe";
+import type { NativeNode } from "../native/node";
+import { formatHashlineHeader } from "./hashline-format";
+import { fileRow } from "./native-view";
 
 // =============================================================================
 // Grouped file output (grep / ast-grep / ast-edit / lsp diagnostics)
@@ -86,6 +91,51 @@ export function formatGroupedFiles(
 	return { model, display };
 }
 
+/** One file's rendered search matches, plus its hashline tag when editable. */
+export interface FileMatchSection {
+	model: string[];
+	display: string[];
+	tag?: string;
+}
+
+/**
+ * Render per-file search matches (grep / ast-grep). Grouped mode nests files
+ * via {@link formatGroupedFiles}, appending `#tag` to headers; flat mode
+ * blank-separates files and prefixes each with a hashline header when tagged.
+ * Files with no model lines are omitted.
+ */
+export function formatFileMatches(
+	files: string[],
+	grouped: boolean,
+	renderFile: (filePath: string) => FileMatchSection,
+): GroupedFilesOutput {
+	if (grouped) {
+		return formatGroupedFiles(files, filePath => {
+			const rendered = renderFile(filePath);
+			return {
+				modelLines: rendered.model,
+				displayLines: rendered.display,
+				headerSuffix: rendered.tag ? `#${rendered.tag}` : "",
+				skip: rendered.model.length === 0,
+			};
+		});
+	}
+	const model: string[] = [];
+	const display: string[] = [];
+	for (const filePath of files) {
+		const rendered = renderFile(filePath);
+		if (rendered.model.length === 0) continue;
+		if (model.length > 0) {
+			model.push("");
+			display.push("");
+		}
+		if (rendered.tag) model.push(formatHashlineHeader(filePath, rendered.tag));
+		model.push(...rendered.model);
+		display.push(...rendered.display);
+	}
+	return { model, display };
+}
+
 // =============================================================================
 // Parsing grouped output back into per-line context (TUI renderers)
 // =============================================================================
@@ -209,3 +259,158 @@ export function groupLineIndicesByBlank(rawLines: readonly string[]): number[][]
 	}
 	return groups;
 }
+
+// =============================================================================
+// Native (TSP) description of grouped output
+// =============================================================================
+
+/** One event of {@link walkGroupedOutput}: a directory header, a file header, or a non-blank body line. */
+export type GroupedOutputEvent =
+	| { readonly kind: "dir" }
+	| { readonly kind: "file"; readonly path: string; readonly suffix?: string }
+	| { readonly kind: "line"; readonly text: string };
+
+/**
+ * Walk grouped output (`# dir/`, `## file.ts (suffix)`, body lines), resolving
+ * each file header to its full display path (the folded directory chain
+ * joined with the name) and dropping blank separator lines.
+ */
+export function* walkGroupedOutput(lines: readonly string[]): Generator<GroupedOutputEvent> {
+	const dirAtDepth: string[] = [];
+	for (const line of lines) {
+		const header = GROUPED_HEADER_RE.exec(line);
+		if (!header) {
+			if (line.trim().length > 0) yield { kind: "line", text: line };
+			continue;
+		}
+		const depth = header[1]!.length;
+		const rest = header[2]!.trimEnd();
+		dirAtDepth.length = depth - 1;
+		if (rest.endsWith("/") && !isUrlLikePath(rest)) {
+			dirAtDepth[depth - 1] = rest.slice(0, -1).replace(HEADER_SUFFIX_RE, "");
+			yield { kind: "dir" };
+			continue;
+		}
+		const suffix = HEADER_SUFFIX_RE.exec(rest)?.[0].trim();
+		const name = rest.replace(HEADER_SUFFIX_RE, "").replace(HEADER_HASH_TAG_RE, "");
+		const prefix = dirAtDepth.filter(Boolean).join("/");
+		yield { kind: "file", path: prefix ? `${prefix}/${name}` : name, suffix };
+	}
+}
+
+/** `*12│text`, ` 12|text`, `*12:text`: optional match marker, line number, gutter, content. */
+const GROUPED_NUMBERED_LINE_RE = /^\s*(\*?)(\d+)(?:│|[:|])(.*)$/;
+
+/** One source line for {@link numberedCode}: its number (`null` for an elision marker), text and match mark. */
+export interface NumberedLine {
+	n: number | null;
+	text: string;
+	mark?: boolean;
+}
+
+/**
+ * Numbered `code` for possibly non-contiguous source lines: one block per run
+ * of consecutive line numbers (`start` = the run's first line, match lines
+ * `mark`ed), with a `…` row wherever the numbers jump or an elision marker
+ * (`n: null`) sits. No path header: the row or head above names the file.
+ */
+export function numberedCode(lines: readonly NumberedLine[], opts: { lang?: string } = {}): NativeNode[] {
+	const out: NativeNode[] = [];
+	let run: { start: number; text: string[]; marks: { line: number; tone: TspTone }[] } | undefined;
+	const flush = () => {
+		if (!run) return;
+		// The quiet `…` row between two non-adjacent runs.
+		if (out.length > 0) out.push(keyed(text([span("…", "dim")], { wrap: "none" }), `g${run.start}`));
+		out.push(
+			keyed(
+				code(run.text.join("\n"), {
+					start: run.start,
+					numbers: true,
+					lang: opts.lang,
+					marks: run.marks.length > 0 ? run.marks : undefined,
+				}),
+				`c${run.start}`,
+			),
+		);
+		run = undefined;
+	};
+	for (const line of lines) {
+		if (line.n === null) {
+			flush();
+			continue;
+		}
+		if (run && run.start + run.text.length !== line.n) flush();
+		run ??= { start: line.n, text: [], marks: [] };
+		run.text.push(line.text);
+		if (line.mark) run.marks.push({ line: line.n, tone: "accent" });
+	}
+	flush();
+	return out;
+}
+
+/**
+ * Describe grouped search output (grep / ast-grep / ast-edit display content)
+ * by file (§7.3 grep): per file a 22px path row (dim dir, strong name, the
+ * header's suffix or the match count as a chip), then its lines as
+ * {@link numberedCode} with match lines marked and `…` between non-adjacent
+ * runs. Unnumbered body lines stay plain `code`. `maxFiles` keeps only the
+ * first files (the caller says how many were left out).
+ */
+export function describeGroupedOutput(
+	lines: readonly string[],
+	options: { lang?: (path: string) => string | undefined; maxFiles?: number } = {},
+): NativeNode[] {
+	const files: NativeNode[] = [];
+	const loose: NativeNode[] = [];
+	let current: { path: string; suffix?: string; children: NativeNode[]; marks: number } | undefined;
+	let numbered: NumberedLine[] = [];
+	let plain: string[] = [];
+
+	const flushLines = () => {
+		const target = current?.children ?? loose;
+		if (numbered.length > 0) {
+			target.push(...numberedCode(numbered, { lang: current ? options.lang?.(current.path) : undefined }));
+			numbered = [];
+		}
+		if (plain.length > 0) {
+			target.push(keyed(code(plain.join("\n")), `p${target.length}`));
+			plain = [];
+		}
+	};
+	const flushFile = () => {
+		flushLines();
+		if (!current) return;
+		const count = current.marks;
+		const chip = current.suffix
+			? { text: current.suffix.replace(/^\(|\)$/g, "") }
+			: count > 0
+				? { text: String(count), title: count === 1 ? "1 match" : `${count} matches` }
+				: undefined;
+		const head = fileRow(current.path, { chip, key: "file" });
+		files.push(
+			keyed(col([head, ...current.children], { gap: "xs", role: "omp.tool.search.file" }), `f:${current.path}`),
+		);
+		current = undefined;
+	};
+
+	for (const event of walkGroupedOutput(lines)) {
+		if (event.kind !== "line") {
+			flushFile();
+			if (options.maxFiles !== undefined && files.length >= options.maxFiles) break;
+			if (event.kind === "file") current = { path: event.path, suffix: event.suffix, children: [], marks: 0 };
+			continue;
+		}
+		const match = GROUPED_NUMBERED_LINE_RE.exec(event.text);
+		if (!match) {
+			if (numbered.length > 0) flushLines();
+			plain.push(event.text);
+			continue;
+		}
+		if (plain.length > 0) flushLines();
+		const mark = match[1] === "*";
+		if (mark && current) current.marks++;
+		numbered.push({ n: Number.parseInt(match[2]!, 10), text: match[3]!, mark });
+	}
+	flushFile();
+	return [...loose, ...files];
+}

package/src/tools/json-tree.ts

@@ -1,11 +1,14 @@
 /**
  * JSON tree rendering utilities shared across tool renderers.
  */
-import { INTENT_FIELD } from "@oh-my-pi/pi-wire";
+import { INTENT_FIELD, type TspSpan, type TspTreeNode } from "@oh-my-pi/pi-wire";
 import { sanitizeText } from "@oh-my-pi/pi-utils";
 import { TreeView, treeRowPrefix } from "../components/tree-view";
 import { truncateToWidth } from "../render/render-utils";
 import type { Theme, ThemeColor } from "../theme/theme";
+import { node, span } from "../native/describe";
+import type { NativeNode } from "../native/node";
+import { plainText } from "../native/spans";
 
 /** Max depth for JSON tree rendering */
 export const JSON_TREE_MAX_DEPTH_COLLAPSED = 2;
@@ -386,3 +389,115 @@ export function renderJsonTreeLines(
 	const rendered = tree.renderWithState(Number.POSITIVE_INFINITY);
 	return { lines: [...rendered.lines], truncated: rendered.truncated || scalarTruncated };
 }
+
+/** Data caps for {@link describeJsonTree}. */
+export interface JsonTreeDescribeOptions {
+	/** Deepest level expanded into child nodes; deeper containers get a `…` child. */
+	maxDepth?: number;
+	/** Tree nodes emitted before the remaining siblings collapse into `… N more`. */
+	maxNodes?: number;
+	/** Characters kept per string scalar (data cap, not a width). */
+	maxScalarLen?: number;
+	/** Levels open initially; deeper containers start closed. */
+	openDepth?: number;
+	/** Root object keys omitted. Defaults to internal tool argument metadata. */
+	hiddenRootKeys?: readonly string[];
+}
+
+type JsonEntry = readonly [key: string, value: unknown];
+
+function clipScalar(value: string, maxLen: number): string {
+	return value.length > maxLen ? `${value.slice(0, maxLen)}…` : value;
+}
+
+function jsonEntries(value: unknown[] | Record<string, unknown>, hidden?: readonly string[]): JsonEntry[] {
+	const out: JsonEntry[] = [];
+	if (Array.isArray(value)) {
+		for (let index = 0; index < value.length; index++) out.push([`[${index}]`, value[index]]);
+		return out;
+	}
+	for (const key in value) {
+		if (!hidden?.includes(key)) out.push([key, value[key]]);
+	}
+	return out;
+}
+
+function jsonScalarToken(value: unknown): string {
+	if (typeof value === "number" || typeof value === "bigint") return "syntaxNumber";
+	if (typeof value === "boolean" || value === null || value === undefined) return "syntaxKeyword";
+	return "dim";
+}
+
+/**
+ * TSP `tree` of a JSON value: containers become expandable nodes labelled with
+ * their key and size, scalars become `key: value` leaves styled by type.
+ * Bounded by depth, node count and scalar length; no width math.
+ */
+export function describeJsonTree(value: unknown, options: JsonTreeDescribeOptions = {}): NativeNode {
+	const maxDepth = Math.max(0, options.maxDepth ?? JSON_TREE_MAX_DEPTH_EXPANDED);
+	const maxScalarLen = Math.max(1, options.maxScalarLen ?? JSON_TREE_SCALAR_LEN_EXPANDED);
+	const openDepth = options.openDepth ?? JSON_TREE_MAX_DEPTH_COLLAPSED;
+	let budget = Math.max(1, options.maxNodes ?? JSON_TREE_MAX_LINES_EXPANDED);
+	let nextId = 0;
+	const leaf = (label: readonly TspSpan[]): TspTreeNode => ({ id: `${nextId++}`, label });
+
+	const describeEntries = (entries: readonly JsonEntry[], depth: number): TspTreeNode[] => {
+		const out: TspTreeNode[] = [];
+		for (let index = 0; index < entries.length; index++) {
+			if (budget <= 0) {
+				out.push(leaf([span(`… ${entries.length - index} more`, "dim")]));
+				break;
+			}
+			const [key, child] = entries[index];
+			out.push(describeValue(key, child, depth));
+		}
+		return out;
+	};
+
+	const describeValue = (key: string | undefined, entry: unknown, depth: number): TspTreeNode => {
+		budget--;
+		const id = `${nextId++}`;
+		const keySpans: TspSpan[] = key === undefined ? [] : [span(plainText(key), "muted")];
+		if (Array.isArray(entry) || isRecord(entry)) {
+			const entries = jsonEntries(entry);
+			const size = Array.isArray(entry) ? `[${entry.length}]` : `{${entries.length}}`;
+			const label = keySpans.length > 0 ? [...keySpans, span(` ${size}`, "dim")] : [span(size, "dim")];
+			if (entries.length === 0) return { id, label };
+			const children = depth >= maxDepth ? [leaf([span("…", "dim")])] : describeEntries(entries, depth + 1);
+			return { id, label, open: depth < openDepth, children };
+		}
+		const prefix = keySpans.length > 0 ? [...keySpans, span(": ", "muted")] : [];
+		if (typeof entry === "string") {
+			const lines = plainText(entry).split("\n");
+			const first = clipScalar(lines[0], maxScalarLen);
+			if (lines.length === 1) return { id, label: [...prefix, span(`"${first}"`, "syntaxString")] };
+			const children: TspTreeNode[] = [];
+			for (let index = 0; index < lines.length; index++) {
+				if (budget <= 0) {
+					children.push(leaf([span(`… ${lines.length - index} more lines`, "dim")]));
+					break;
+				}
+				budget--;
+				children.push(leaf([span(clipScalar(lines[index], maxScalarLen), "syntaxString")]));
+			}
+			return {
+				id,
+				label: [...prefix, span(`"${first}…"`, "syntaxString"), span(` (${lines.length} lines)`, "dim")],
+				open: false,
+				children,
+			};
+		}
+		return { id, label: [...prefix, span(plainText(formatScalar(entry, maxScalarLen)), jsonScalarToken(entry))] };
+	};
+
+	let nodes: TspTreeNode[];
+	if (Array.isArray(value) || isRecord(value)) {
+		const hidden = Array.isArray(value) ? undefined : (options.hiddenRootKeys ?? DEFAULT_HIDDEN_ROOT_KEYS);
+		const entries = jsonEntries(value, hidden);
+		nodes =
+			entries.length > 0 ? describeEntries(entries, 1) : [leaf([span(Array.isArray(value) ? "[]" : "{}", "dim")])];
+	} else {
+		nodes = [describeValue(undefined, value, 0)];
+	}
+	return node("tree", { nodes });
+}