pi-hashline-edit-pro 7.0.0 → 7.1.1

package/src/grep.ts

@@ -15,6 +15,7 @@ import { loadP, loadGuidelines } from "./prompts";
 import { normReq } from "./payload-contract";
 import { DEFAULT_EDIT_FLAGS, withGrepPrompts, type EditToolFlags } from "./edit-common";
 import { abortIf, clipLine, errCode, isRec, makePrepareArguments, rejectUnknownFields, truncateToBytes, visLines, gutterWidth } from "./utils";
+import type { LineEnding } from "./normalize";
 import { withAnchorSession, formatAnchorReclaimNotice, takeReclaimedPaths } from "./anchor-registry";
 import { serveRows } from "./served";
 import { Text } from "@earendil-works/pi-tui";
@@ -139,6 +140,62 @@ function grepHeadFragment(line: string): string {
   return head.length < line.length ? `${head}...` : head;
 }
 
+function lineStartsOf(text: string): number[] {
+  const starts = [0];
+  for (let index = 0; index < text.length; index += 1) {
+    if (text.charCodeAt(index) === 10 && index + 1 < text.length) starts.push(index + 1);
+  }
+  return starts;
+}
+
+function physicalStartsOf(text: string, separators: readonly LineEnding[]): number[] {
+  const starts = [0];
+  let separatorIndex = 0;
+  for (let index = 0; index < text.length; index += 1) {
+    if (text.charCodeAt(index) !== 10) continue;
+    const separator = separators[separatorIndex] ?? "\n";
+    separatorIndex += 1;
+    if (separator === "\n" || separator === "\r\n") starts.push(index + 1);
+  }
+  return starts;
+}
+
+function lineIndexOf(starts: readonly number[], position: number): number {
+  let low = 0;
+  let high = starts.length - 1;
+  while (low < high) {
+    const mid = (low + high + 1) >>> 1;
+    if (starts[mid]! <= position) low = mid;
+    else high = mid - 1;
+  }
+  return low;
+}
+
+function toNormalizedMatches(
+  norm: { normalized: string; endingSeparators: readonly LineEnding[] },
+  matches: RgMatchLine[],
+): RgMatchLine[] {
+  if (!norm.endingSeparators.includes("\r")) return matches;
+  const text = norm.normalized;
+  const starts = lineStartsOf(text);
+  const physical = physicalStartsOf(text, norm.endingSeparators);
+  const lines = visLines(text);
+  return matches.map((match) => {
+    const base = physical[match.line - 1] ?? 0;
+    const physicalLine = text.slice(base, physical[match.line] ?? text.length);
+    const position = base + byteOffsetToCharIndex(physicalLine, match.start);
+    const index = lineIndexOf(starts, position);
+    const lineText = lines[index] ?? "";
+    const columnStart = Math.min(position - starts[index]!, lineText.length);
+    const columnEnd = Math.min(base + byteOffsetToCharIndex(physicalLine, match.end) - starts[index]!, lineText.length);
+    return {
+      line: index + 1,
+      start: Buffer.byteLength(lineText.slice(0, columnStart), "utf-8"),
+      end: Buffer.byteLength(lineText.slice(0, Math.max(columnStart, columnEnd)), "utf-8"),
+    };
+  });
+}
+
 function makeHitFromIndices(
   norm: { normalized: string; fileHashes: string[]; absolutePath: string; hadUtf8DecodeErrors: boolean },
   displayPath: string,
@@ -247,6 +304,11 @@ async function insideGitRepo(start: string): Promise<boolean> {
   }
 }
 
+interface RgSearch {
+  matches: Map<string, RgMatchLine[]>;
+  skipped?: string;
+}
+
 async function collectRgMatches(
   rgPath: string,
   pattern: string,
@@ -254,8 +316,8 @@ async function collectRgMatches(
   req: GrepReq,
   signal: AbortSignal | undefined,
   repoRooted: boolean,
-): Promise<Map<string, RgMatchLine[]>> {
-  const args = ["--json", "--line-number", "--color=never", "--hidden", "--glob", "!.git"];
+): Promise<RgSearch> {
+  const args = ["--json", "--line-number", "--color=never", "--hidden", "--crlf", "--glob", "!.git"];
   if (!repoRooted) args.push("--no-require-git");
   const wanted = req.limit ?? 100;
   args.push("--max-count", String(wanted + 1));
@@ -267,7 +329,7 @@ async function collectRgMatches(
   if (req.literal) args.push("--fixed-strings");
   args.push("--", pattern, searchPath);
   const result = new Map<string, RgMatchLine[]>();
-  return await new Promise<Map<string, RgMatchLine[]>>((resolve, reject) => {
+  return await new Promise<RgSearch>((resolve, reject) => {
     const child = spawn(rgPath, args, { stdio: ["ignore", "pipe", "pipe"] });
     const rl = createInterface({ input: child.stdout });
     let stderr = "";
@@ -331,12 +393,16 @@ async function collectRgMatches(
       }
       if (code !== 0 && code !== 1) {
         const detail = clipLine(stderr.trim(), 300);
-        reject(new Error(detail
-          ? `[E_GREP_FAILED] ripgrep exited with code ${code}: ${detail}`
-          : `[E_GREP_FAILED] ripgrep exited with code ${code}.`));
+        if (result.size === 0) {
+          reject(new Error(detail
+            ? `[E_GREP_FAILED] ripgrep exited with code ${code}: ${detail}`
+            : `[E_GREP_FAILED] ripgrep exited with code ${code}.`));
+          return;
+        }
+        resolve({ matches: result, ...(detail ? { skipped: detail } : {}) });
         return;
       }
-      resolve(result);
+      resolve({ matches: result });
     });
   });
 }
@@ -541,7 +607,8 @@ export function regGrep(pi: ExtensionAPI, flags: EditToolFlags = DEFAULT_EDIT_FL
         const readGrepFile = makeGrepReader("real");
         const readGrepFileShadow = makeGrepReader("shadow");
         const repoRooted = await insideGitRepo(globRoot);
-        const rgMatches = await collectRgMatches(rgPath, req.pattern, base, req, signal, repoRooted);
+        const rgSearch = await collectRgMatches(rgPath, req.pattern, base, req, signal, repoRooted);
+        const rgMatches = rgSearch.matches;
         const sortedFiles = [...rgMatches.keys()].sort(cmp);
         for (let f = 0; f < sortedFiles.length; f++) {
           abortIf(signal);
@@ -552,7 +619,7 @@ export function regGrep(pi: ExtensionAPI, flags: EditToolFlags = DEFAULT_EDIT_FL
             if (!matchesGlob(absPath)) continue;
             const norm = await readGrepFileShadow(absPath);
             if (!norm) continue;
-            const hit = makeHitFromIndices(norm, toDisplayPath(ctx.cwd, absPath), fileMatches, context, totalForFile, fileMatches.length);
+            const hit = makeHitFromIndices(norm, toDisplayPath(ctx.cwd, absPath), toNormalizedMatches(norm, fileMatches), context, totalForFile, fileMatches.length);
             const display = displayRowsForHit(hit);
             totalRows += display.length;
             for (const r of display) totalBytes += Buffer.byteLength(r, "utf-8") + 1;
@@ -574,7 +641,7 @@ export function regGrep(pi: ExtensionAPI, flags: EditToolFlags = DEFAULT_EDIT_FL
           if (!matchesGlob(absPath)) continue;
           const norm = await readGrepFile(absPath);
           if (!norm) continue;
-          const hit = makeHitFromIndices(norm, toDisplayPath(ctx.cwd, absPath), fileMatches, context, totalForFile, Math.min(totalForFile, remaining));
+          const hit = makeHitFromIndices(norm, toDisplayPath(ctx.cwd, absPath), toNormalizedMatches(norm, fileMatches), context, totalForFile, Math.min(totalForFile, remaining));
           const display = displayRowsForHit(hit);
           const keptRows: string[] = [];
           const keptHashes: string[] = [];
@@ -624,6 +691,7 @@ export function regGrep(pi: ExtensionAPI, flags: EditToolFlags = DEFAULT_EDIT_FL
         if (limitTruncated) notes.push(`[grep: showing first ${limit} matches; increase limit to see more.]`);
         if (linesReplaced > 0) notes.push(`[grep: ${linesReplaced} line(s) exceed ${formatSize(MAX_GREP_LINE_BYTES)} and are shown as truncated fragments; use read to see the full lines.]`);
         if (poolSkipped > 0) notes.push(`[grep: ${poolSkipped} file(s) skipped because the session's anchor pool is exhausted; narrow the search.]`);
+        if (rgSearch.skipped !== undefined) notes.push(`[grep: some paths could not be searched, so these results are partial: ${rgSearch.skipped}]`);
         const truncated = limitTruncated || rowTruncated;
         const truncation: TruncationResult | undefined = rowTruncated
           ? {

package/src/hashline/resolve.ts

@@ -113,9 +113,12 @@ export function fmtMismatchWithHashes(
       for (let ln = from; ln <= to; ln++) {
         const h = fileHashes[ln - 1]!;
         const c = fileLines[ln - 1] ?? "";
-        hashes.push(h);
-        servedMap.set(h, lineChecksum(c));
-        rows.push(`    ${ln}: ${h}│${clipLine(c)}`);
+        const shown = clipLine(c);
+        if (shown === c) {
+          hashes.push(h);
+          servedMap.set(h, lineChecksum(c));
+        }
+        rows.push(`    ${ln}: ${h}│${shown}`);
       }
       out.push("");
       out.push(`  Current context around resolved anchor "${ctx.hash}" (line ${ctx.line}):\n${rows.join("\n")}`);
@@ -441,12 +444,18 @@ export function assertRangeServed(
   const rows: string[] = [];
   const shownHashes: string[] = [];
   const shownMap = new Map<string, string>();
+  const clippedLines: number[] = [];
   for (let line = startLine; line < startLine + shownLength; line++) {
     const hash = fileHashes[line - 1]!;
     const content = fileLines[line - 1]!;
+    const shown = clipLine(content);
+    rows.push(fmtRow(hash, shown));
+    if (shown !== content) {
+      clippedLines.push(line);
+      continue;
+    }
     shownHashes.push(hash);
     shownMap.set(hash, lineChecksum(content));
-    rows.push(fmtRow(hash, clipLine(content)));
   }
   const location = filePath ? ` in ${filePath}` : "";
   const rangeDescription = `the replaced range (lines ${startLine}-${endLine})${location}`;
@@ -457,7 +466,9 @@ export function assertRangeServed(
   const capHint =
     rangeLength > shownLength
       ? `\n\n[The range has ${rangeLength} lines; showing the first ${shownLength}. Call read()${filePath ? ` on ${filePath}` : ""} with offset=${startLine + shownLength} to see the rest.]`
-      : "\n\nRetry with the fresh anchors above without a read.";
+      : clippedLines.length > 0
+        ? `\n\n[${clippedLines.length === 1 ? `Line ${clippedLines[0]} is` : `Lines ${clippedLines.join(", ")} are`} clipped above and not editable from here; call read()${filePath ? ` on ${filePath}` : ""} before editing.]`
+        : "\n\nRetry with the fresh anchors above without a read.";
   const message =
     `[E_RANGE_STALE] ${mismatchText}. Current range with fresh anchors:\n\n${rows.join("\n")}${capHint}`;
   throw new RangeStaleError(message, shownHashes, shownMap);

package/src/model-gate.ts

@@ -6,6 +6,7 @@ export interface ModelLike {
 
 export const ANCHOR_TOOL_NAMES: readonly string[] = [
   "read",
+  "outline",
   "replace",
   "replace_match",
   "insert",

package/src/outline/index.ts

@@ -18,7 +18,7 @@ export async function buildFileOutline(input: FileOutlineInput): Promise<Outline
 	const parser = await loadOutlineParser();
 	const parsed = parser === undefined ? undefined : await parser.parse(input.displayPath, input.content);
 	if (parsed !== undefined && parsed.symbols.length > 0) {
-		return renderSymbolOutline({
+		const outline = renderSymbolOutline({
 			displayPath: input.displayPath,
 			languageName: parsed.languageName,
 			totalLines: lines.length,
@@ -29,8 +29,9 @@ export async function buildFileOutline(input: FileOutlineInput): Promise<Outline
 			...(input.maxDepth !== undefined ? { maxDepth: input.maxDepth } : {}),
 			...(input.maxBytes !== undefined ? { maxBytes: input.maxBytes } : {}),
 		});
+		return parsed.hasSyntaxErrors ? { ...outline, hasSyntaxErrors: true } : outline;
 	}
-	return renderPreviewOutline({
+	const preview = renderPreviewOutline({
 		displayPath: input.displayPath,
 		lines,
 		hashes: input.hashes,
@@ -38,6 +39,8 @@ export async function buildFileOutline(input: FileOutlineInput): Promise<Outline
 		...(input.previewTailLines !== undefined ? { tailLines: input.previewTailLines } : {}),
 		...(input.maxBytes !== undefined ? { maxBytes: input.maxBytes } : {}),
 	});
+	if (lines.length === 0) return preview;
+	return { ...preview, preview: parsed === undefined ? "unsupported" : "no-symbols", ...(parsed?.hasSyntaxErrors ? { hasSyntaxErrors: true } : {}) };
 }
 
 export { loadOutlineParser } from "./parsers";

package/src/outline/parsers.ts

@@ -4,12 +4,12 @@ export interface OutlineSymbol {
 	startLine: number;
 	endLine: number;
 	children?: OutlineSymbol[];
-	detail?: string;
 }
 
 export interface OutlineParse {
 	symbols: OutlineSymbol[];
 	languageName: string;
+	hasSyntaxErrors: boolean;
 }
 
 export interface OutlineParser {
@@ -25,7 +25,7 @@ async function load(): Promise<OutlineParser | undefined> {
 			parse: async (path, content) => {
 				if (parsers.detectLanguage(path) === null) return undefined;
 				const parsed = await parsers.parseSourceFile(path, content);
-				return { symbols: parsed.symbols, languageName: parsed.languageName };
+				return { symbols: parsed.symbols, languageName: parsed.languageName, hasSyntaxErrors: parsed.hasError === true };
 			},
 		};
 	} catch (error) {

package/src/outline/render.ts

@@ -1,14 +1,18 @@
 import { DEFAULT_MAX_BYTES } from "@earendil-works/pi-coding-agent";
+import { HASH_SEP } from "../hashline";
 import { clipLine } from "../utils";
 import type { OutlineSymbol } from "./parsers";
 
 const DEFAULT_MAX_ROWS = 400;
 const DEFAULT_MAX_DEPTH = 6;
-const MAX_DETAIL_CHARS = 60;
 const PREVIEW_HEAD_LINES = 20;
 const PREVIEW_TAIL_LINES = 10;
 const PREVIEW_LINE_CHARS = 200;
 
+function formatMoreLines(count: number): string {
+	return `... (${count} more ${count === 1 ? "line" : "lines"})`;
+}
+
 export interface OutlineRow {
 	line: number;
 	anchor: string;
@@ -20,6 +24,9 @@ export interface OutlineRender {
 	rows: OutlineRow[];
 	servedHashes: string[];
 	truncated: boolean;
+	complete: boolean;
+	preview?: "unsupported" | "no-symbols";
+	hasSyntaxErrors?: boolean;
 }
 
 export interface SymbolOutlineInput {
@@ -43,64 +50,118 @@ export interface PreviewOutlineInput {
 	maxBytes?: number;
 }
 
-function servedHashesOf(rows: OutlineRow[]): string[] {
-	return [...new Set(rows.map((row) => row.anchor))];
+interface OutlineBudget {
+	output: string[];
+	rows: OutlineRow[];
+	servedHashes: string[];
+	maxRows: number;
+	maxBytes: number;
+	bytes: number;
+	truncated: boolean;
+	truncation?: "rows" | "bytes";
+	skipped: number;
+}
+
+function startBudget(header: string, maxRows: number, maxBytes: number): OutlineBudget {
+	return { output: [header], rows: [], servedHashes: [], maxRows, maxBytes, bytes: Buffer.byteLength(header, "utf-8") + 1, truncated: false, skipped: 0 };
+}
+
+function pushLine(budget: OutlineBudget, text: string): boolean {
+	const size = Buffer.byteLength(text, "utf-8") + 1;
+	if (budget.bytes + size > budget.maxBytes) return false;
+	budget.bytes += size;
+	budget.output.push(text);
+	return true;
+}
+
+function markTruncated(budget: OutlineBudget, cause: "rows" | "bytes"): void {
+	budget.truncated = true;
+	if (budget.truncation === undefined) budget.truncation = cause;
+}
+
+function isComplete(budget: OutlineBudget): boolean {
+	return !budget.truncated && budget.skipped === 0 && budget.servedHashes.length === budget.rows.length;
+}
+
+type EmitOutcome = "emitted" | "skipped" | "stopped";
+
+function emitRow(budget: OutlineBudget, hashes: string[], lines: string[], line: number, text: string): EmitOutcome {
+	const anchor = hashes[line - 1];
+	if (anchor === undefined) {
+		budget.skipped += 1;
+		return "skipped";
+	}
+	if (budget.rows.length >= budget.maxRows) {
+		markTruncated(budget, "rows");
+		return "stopped";
+	}
+	if (!pushLine(budget, `${anchor}${HASH_SEP}${text}`)) {
+		markTruncated(budget, "bytes");
+		return "stopped";
+	}
+	budget.rows.push({ line, anchor, text });
+	if (text === (lines[line - 1] ?? "")) budget.servedHashes.push(anchor);
+	return "emitted";
 }
 
-function countSymbols(symbols: OutlineSymbol[]): number {
+function countSymbolRows(
+	symbols: OutlineSymbol[],
+	depth: number,
+	maxDepth: number,
+	hashes: string[],
+	seenLines: Set<number>,
+): number {
 	let total = 0;
 	for (const symbol of symbols) {
-		total += 1;
-		if (symbol.children) total += countSymbols(symbol.children);
+		const children = symbol.children ?? [];
+		if (seenLines.has(symbol.startLine)) {
+			if (children.length > 0 && depth < maxDepth) total += countSymbolRows(children, depth + 1, maxDepth, hashes, seenLines);
+			continue;
+		}
+		seenLines.add(symbol.startLine);
+		if (hashes[symbol.startLine - 1] !== undefined) total += 1;
+		if (children.length === 0 || depth >= maxDepth) continue;
+		total += countSymbolRows(children, depth + 1, maxDepth, hashes, seenLines);
 	}
 	return total;
 }
 
-function symbolLabel(symbol: OutlineSymbol, depth: number): string {
-	const indent = "  ".repeat(depth);
-	const name = symbol.name.length > 0 ? ` ${symbol.name}` : "";
-	const detail = symbol.detail !== undefined && symbol.detail.length > 0
-		? ` ${symbol.detail.length > MAX_DETAIL_CHARS ? `${symbol.detail.slice(0, MAX_DETAIL_CHARS - 3)}...` : symbol.detail}`
-		: "";
-	const children = symbol.children !== undefined && symbol.children.length > 0 ? ` (${symbol.children.length} children)` : "";
-	const span = symbol.endLine - symbol.startLine + 1;
-	return `${indent}${symbol.type}${name}${detail}${children}${span > 1 ? ` [limit ${span}]` : ""}`;
-}
-
 export function renderSymbolOutline(input: SymbolOutlineInput): OutlineRender {
-	const maxRows = input.maxRows ?? DEFAULT_MAX_ROWS;
-	const maxDepth = input.maxDepth ?? DEFAULT_MAX_DEPTH;
-	const maxBytes = input.maxBytes ?? DEFAULT_MAX_BYTES;
 	const header = `=== ${input.displayPath}${input.languageName !== undefined ? ` (${input.languageName})` : ""} — ${input.totalLines} lines ===`;
-	const rows: OutlineRow[] = [];
-	const output: string[] = [header];
-	let bytes = Buffer.byteLength(header, "utf-8") + 1;
-	let truncated = false;
-
-	const addRow = (line: number, text: string): boolean => {
-		const anchor = input.hashes[line - 1];
-		if (anchor === undefined) return true;
-		const rendered = `${anchor}│${text}`;
-		const size = Buffer.byteLength(rendered, "utf-8") + 1;
-		if (rows.length >= maxRows || bytes + size > maxBytes) {
-			truncated = true;
-			return false;
-		}
-		bytes += size;
-		output.push(rendered);
-		rows.push({ line, anchor, text });
-		return true;
-	};
+	const budget = startBudget(header, input.maxRows ?? DEFAULT_MAX_ROWS, input.maxBytes ?? DEFAULT_MAX_BYTES);
+	const maxDepth = input.maxDepth ?? DEFAULT_MAX_DEPTH;
+	const seenLines = new Set<number>();
 
 	const walk = (symbols: OutlineSymbol[], depth: number): boolean => {
 		for (const symbol of symbols) {
-			const contentLine = symbol.endLine === symbol.startLine ? input.lines[symbol.startLine - 1] : undefined;
-			const text = contentLine === undefined ? symbolLabel(symbol, depth) : clipLine(contentLine, PREVIEW_LINE_CHARS);
-			if (!addRow(symbol.startLine, text)) return false;
+			if (seenLines.has(symbol.startLine)) {
+				const children = symbol.children ?? [];
+				if (children.length > 0) {
+					if (depth < maxDepth) {
+						if (!walk(children, depth + 1)) return false;
+					} else if (!pushLine(budget, `[${children.length} nested]`)) {
+						markTruncated(budget, "bytes");
+						return false;
+					}
+				}
+				continue;
+			}
+			seenLines.add(symbol.startLine);
+			const text = clipLine(input.lines[symbol.startLine - 1] ?? "", PREVIEW_LINE_CHARS);
+			const outcome = emitRow(budget, input.hashes, input.lines, symbol.startLine, text);
+			if (outcome === "stopped") return false;
+			const span = symbol.endLine - symbol.startLine + 1;
+			if (outcome === "emitted" && span > 1 && !pushLine(budget, `[limit ${span}]`)) {
+				markTruncated(budget, "bytes");
+				return false;
+			}
 			const children = symbol.children ?? [];
 			if (children.length === 0) continue;
 			if (depth >= maxDepth) {
-				output.push(`${"  ".repeat(depth + 1)}(${children.length} nested items)`);
+				if (!pushLine(budget, `[${children.length} nested]`)) {
+					markTruncated(budget, "bytes");
+					return false;
+				}
 				continue;
 			}
 			if (!walk(children, depth + 1)) return false;
@@ -109,62 +170,75 @@ export function renderSymbolOutline(input: SymbolOutlineInput): OutlineRender {
 	};
 
 	walk(input.symbols, 0);
-	if (truncated) {
-		output.push(`... (${countSymbols(input.symbols) - rows.length} more symbols)`);
+	if (budget.truncated) {
+		const remaining = countSymbolRows(input.symbols, 0, maxDepth, input.hashes, new Set<number>()) - budget.rows.length;
+		const more = remaining > 0 ? ` (${remaining} more ${remaining === 1 ? "symbol" : "symbols"})` : "";
+		const cause = budget.truncation === "rows" ? "row cap" : "byte budget";
+		if (budget.rows.length === 0) {
+			budget.output.push(more.length > 0
+				? `...${more}; outline truncated by the ${cause} before the first row.`
+				: `... (outline truncated by the ${cause} before the first row.)`);
+		} else if (remaining > 0) {
+			budget.output.push(`...${more}; read from the last shown anchor to continue.`);
+		} else {
+			budget.output.push(`... (outline truncated by the ${cause}; read from the last shown anchor to continue.)`);
+		}
 	}
-	return { text: output.join("\n"), rows, servedHashes: servedHashesOf(rows), truncated };
+	return { text: budget.output.join("\n"), rows: budget.rows, servedHashes: budget.servedHashes, truncated: budget.truncated, complete: isComplete(budget) };
 }
 
 export function renderPreviewOutline(input: PreviewOutlineInput): OutlineRender {
-	const headCount = input.headLines ?? PREVIEW_HEAD_LINES;
-	const tailCount = input.tailLines ?? PREVIEW_TAIL_LINES;
-	const maxBytes = input.maxBytes ?? DEFAULT_MAX_BYTES;
 	const header = `=== ${input.displayPath} — ${input.lines.length} lines ===`;
-	const rows: OutlineRow[] = [];
-	const output: string[] = [header];
-	let bytes = Buffer.byteLength(header, "utf-8") + 1;
-	let truncated = false;
+	const budget = startBudget(header, Number.POSITIVE_INFINITY, input.maxBytes ?? DEFAULT_MAX_BYTES);
 	if (input.lines.length === 0) {
 		const anchor = input.hashes[0];
 		if (anchor !== undefined) {
-			output.push(`${anchor}│`, "[File is empty. Use replace to insert content.]");
-			rows.push({ line: 1, anchor, text: "" });
+			const marker = `${anchor}${HASH_SEP}`;
+			const note = "[File is empty. Use replace to insert content.]";
+			if (pushLine(budget, marker)) {
+				budget.rows.push({ line: 1, anchor, text: "" });
+				budget.servedHashes.push(anchor);
+				if (!pushLine(budget, note)) markTruncated(budget, "bytes");
+			} else {
+				markTruncated(budget, "bytes");
+			}
 		}
-		return { text: output.join("\n"), rows, servedHashes: servedHashesOf(rows), truncated: false };
+		return {
+			text: budget.output.join("\n"),
+			rows: budget.rows,
+			servedHashes: budget.servedHashes,
+			truncated: budget.truncated,
+			complete: isComplete(budget),
+		};
 	}
 
-	const addRow = (index: number): boolean => {
-		const line = input.lines[index];
-		const anchor = input.hashes[index];
-		if (line === undefined || anchor === undefined) return true;
-		const text = clipLine(line, PREVIEW_LINE_CHARS);
-		const rendered = `${anchor}│${text}`;
-		const size = Buffer.byteLength(rendered, "utf-8") + 1;
-		if (bytes + size > maxBytes) {
-			truncated = true;
-			return false;
-		}
-		bytes += size;
-		output.push(rendered);
-		rows.push({ line: index + 1, anchor, text });
-		return true;
-	};
+	const head = Math.min(input.headLines ?? PREVIEW_HEAD_LINES, input.lines.length);
+	const tail = Math.min(input.tailLines ?? PREVIEW_TAIL_LINES, input.lines.length - head);
+	const attempt = (index: number): EmitOutcome => emitRow(budget, input.hashes, input.lines, index + 1, clipLine(input.lines[index] ?? "", PREVIEW_LINE_CHARS));
 
-	const head = Math.min(headCount, input.lines.length);
-	const tail = Math.min(tailCount, input.lines.length - head);
 	for (let index = 0; index < head; index += 1) {
-		if (!addRow(index)) break;
+		if (attempt(index) === "stopped") break;
 	}
-	if (!truncated && head + tail < input.lines.length) {
-		output.push(`... (${input.lines.length - head - tail} more lines)`);
+	let middleIndex: number | undefined;
+	if (!budget.truncated && head + tail < input.lines.length) {
+		if (pushLine(budget, formatMoreLines(input.lines.length - head - tail))) middleIndex = budget.output.length - 1;
+		else markTruncated(budget, "bytes");
 	}
-	if (!truncated) {
+	if (!budget.truncated) {
 		for (let index = input.lines.length - tail; index < input.lines.length; index += 1) {
-			if (!addRow(index)) break;
+			if (attempt(index) === "stopped") break;
 		}
 	}
-	if (truncated) {
-		output.push(`... (${input.lines.length - rows.length} more lines)`);
+	if (budget.truncated) {
+		const remaining = input.lines.length - budget.rows.length;
+		if (middleIndex !== undefined) budget.output.splice(middleIndex, 1);
+		if (remaining > 0) budget.output.push(formatMoreLines(remaining));
 	}
-	return { text: output.join("\n"), rows, servedHashes: servedHashesOf(rows), truncated };
+	return {
+		text: budget.output.join("\n"),
+		rows: budget.rows,
+		servedHashes: budget.servedHashes,
+		truncated: budget.truncated,
+		complete: head + tail >= input.lines.length && isComplete(budget),
+	};
 }

package/src/outline/vendor/README.md

@@ -9,6 +9,10 @@ These files are copied from [pi-codebase-reader](https://github.com/HanzCEO/pi-c
 - `parsers/manager.ts` extracts anonymous default exports (`export default function`/`class`), function expressions, top-level variable declarators, and nested `describe`/`test`/`it` calls, so entry-point, config, data, and test files outline instead of falling back to a preview.
 - `parsers/manager.ts` adds PHP support: `parsers/php.ts` outlines classes, interfaces, traits, enums, methods, properties, constants, top-level functions, and assigned closures.
 - `parsers/manager.ts` adds Blade support: `parsers/blade.ts` outlines `@section`/`@push`/`@once`/`@php` blocks, named directives such as `@extends` and `@include`, and `<x-…>`/`<livewire:…>` components.
+- `parsers/java.ts` reads the field-based tree-sitter-java grammar shipped in `wasm/` (method, constructor, field, constant, enum, record, and annotation-element nodes), so annotated members keep their names; every member anchors on its declaration line rather than on its annotation.
+- `parsers/php.ts` anchors a declaration on its first line after its attributes, so a member with `#[Test]` starts on the declaration instead of the attribute.
+- `types.ts` and every parser drop the upstream `detail` string: outlines render the first line of each symbol's declaration, so the parameters, inheritance, and qualifier text was computed and discarded.
+- `types.ts` keeps `SymbolInfo.name` and `SymbolInfo.type`: the extractors use them while building symbol trees and the upstream contract carries them, even though outlines render a real file line for each symbol.
 
 The `wasm/` grammars come from the MIT-licensed `tree-sitter-javascript`, `tree-sitter-typescript`, `tree-sitter-python`, `tree-sitter-go`, `tree-sitter-rust`, `tree-sitter-solidity`, and `tree-sitter-java` packages, plus pi-codebase-reader's vendored Sass and SCSS grammars, the VS Code WebAssembly build of `tree-sitter-php`, and `tree-sitter-blade` built from v0.12.3; see `wasm/LICENSES.md` for the per-grammar copyright notices. Comments in these files are upstream prose and are exempt from this repository's no-comments rule.
 

package/src/outline/vendor/parsers/blade.ts

@@ -62,8 +62,13 @@ function bodyStart(node: Node): number {
 }
 
 function blockSymbol(node: Node, source: string): SymbolInfo | null {
+  const directive = node.namedChildren[0];
+  if (directive?.type === "directive_start" && (node.type === "conditional" || node.type === "loop")) {
+    const [startLine, endLine] = rangeOf(node);
+    return { name: parameterName(node, source), type: textOf(directive, source).slice(1), startLine, endLine };
+  }
   const label = BLOCK_LABELS[node.type];
-  if (label === undefined) return null;
+  if (label === undefined || (node.type === "php_statement" && directive?.type !== "directive_start")) return null;
   const [startLine, endLine] = rangeOf(node);
   return { name: parameterName(node, source), type: label, startLine, endLine };
 }
@@ -76,7 +81,7 @@ function directiveSymbol(node: Node, parameter: Node | null, source: string): Sy
   const raw = textOf(parameter, source);
   const quoted = unquote(raw);
   return quoted === undefined
-    ? { name: "", type: label, startLine, endLine, detail: raw.trim() }
+    ? { name: "", type: label, startLine, endLine }
     : { name: quoted, type: label, startLine, endLine };
 }
 

package/src/outline/vendor/parsers/index.ts

@@ -21,6 +21,7 @@ export interface ParseFileResult {
   symbols: SymbolInfo[];
   language: string | null;
   languageName: string;
+  hasError?: boolean;
 }
 
 /**
@@ -38,8 +39,8 @@ export async function parseSourceFile(
   }
 
   try {
-    const symbols = await parseCode(lang, content);
-    return { symbols, language: lang, languageName: languageLabel(lang) };
+    const { symbols, hasError } = await parseCode(lang, content);
+    return { symbols, language: lang, languageName: languageLabel(lang), hasError };
   } catch (err) {
     console.warn(
       `[codebase-reader] Parse failed for ${filePath}:`,