pi-lens 3.1.2 → 3.2.0

package/index.ts

@@ -1,6 +1,7 @@
 import * as nodeFs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
+// RELOADED: Testing format/lsp flow on large file
 import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
 import { isToolCallEventType } from "@mariozechner/pi-coding-agent";
 import { Type } from "@sinclair/typebox";
@@ -20,6 +21,7 @@ import { ComplexityClient } from "./clients/complexity-client.js";
 import { DependencyChecker } from "./clients/dependency-checker.js";
 import { dispatchLintWithBus } from "./clients/dispatch/bus-dispatcher.js";
 import { dispatchLint } from "./clients/dispatch/integration.js";
+import { createFileTime, FileTimeError } from "./clients/file-time.js";
 import {
 	getFormatService,
 	resetFormatService,
@@ -584,6 +586,172 @@ export default function (pi: ExtensionAPI) {
 		},
 	});
 
+	// --- LSP Navigation Tool (requires --lens-lsp) ---
+	// Exposes go-to-definition, find-references, hover, documentSymbol, workspaceSymbol, goToImplementation
+	pi.registerTool({
+		name: "lsp_navigation",
+		label: "LSP Navigate",
+		description:
+			"Navigate code using LSP (Language Server Protocol). Requires --lens-lsp flag.\n" +
+			"Operations:\n" +
+			"- definition: Jump to where a symbol is defined\n" +
+			"- references: Find all usages of a symbol\n" +
+			"- hover: Get type/doc info at a position\n" +
+			"- documentSymbol: List all symbols (functions/classes/vars) in a file\n" +
+			"- workspaceSymbol: Search symbols across the whole project\n" +
+			"- implementation: Jump to interface implementations\n\n" +
+			"Line and character are 1-based (as shown in editors).",
+		promptSnippet:
+			"Use lsp_navigation to find definitions, references, and hover info via LSP",
+		parameters: Type.Object({
+			operation: Type.Union(
+				[
+					Type.Literal("definition"),
+					Type.Literal("references"),
+					Type.Literal("hover"),
+					Type.Literal("documentSymbol"),
+					Type.Literal("workspaceSymbol"),
+					Type.Literal("implementation"),
+				],
+				{ description: "LSP operation to perform" },
+			),
+			filePath: Type.String({
+				description: "Absolute or relative path to the file",
+			}),
+			line: Type.Optional(
+				Type.Number({
+					description:
+						"Line number (1-based). Required for definition/references/hover/implementation",
+				}),
+			),
+			character: Type.Optional(
+				Type.Number({
+					description:
+						"Character offset (1-based). Required for definition/references/hover/implementation",
+				}),
+			),
+			query: Type.Optional(
+				Type.String({
+					description: "Symbol name to search. Used by workspaceSymbol",
+				}),
+			),
+		}),
+		async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
+			if (!pi.getFlag("lens-lsp")) {
+				return {
+					content: [
+						{
+							type: "text" as const,
+							text: "lsp_navigation requires the --lens-lsp flag. Start pi with --lens-lsp to enable.",
+						},
+					],
+					isError: true,
+					details: {},
+				};
+			}
+
+			const {
+				operation,
+				filePath: rawPath,
+				line,
+				character,
+				query,
+			} = params as {
+				operation: string;
+				filePath: string;
+				line?: number;
+				character?: number;
+				query?: string;
+			};
+
+			const filePath = path.isAbsolute(rawPath)
+				? rawPath
+				: path.resolve(ctx.cwd || ".", rawPath);
+
+			const lspService = getLSPService();
+			const hasLSP = await lspService.hasLSP(filePath);
+			if (!hasLSP) {
+				return {
+					content: [
+						{
+							type: "text" as const,
+							text: `No LSP server available for ${path.basename(filePath)}. Check that the language server is installed.`,
+						},
+					],
+					isError: true,
+					details: {},
+				};
+			}
+
+			// Ensure file is open in LSP before querying
+			let fileContent: string | undefined;
+			try {
+				fileContent = nodeFs.readFileSync(filePath, "utf-8");
+			} catch {
+				/* ignore */
+			}
+			if (fileContent) await lspService.openFile(filePath, fileContent);
+
+			// Convert 1-based editor coords to 0-based LSP coords
+			const lspLine = (line ?? 1) - 1;
+			const lspChar = (character ?? 1) - 1;
+
+			let result: unknown;
+			try {
+				switch (operation) {
+					case "definition":
+						result = await lspService.definition(filePath, lspLine, lspChar);
+						break;
+					case "references":
+						result = await lspService.references(filePath, lspLine, lspChar);
+						break;
+					case "hover":
+						result = await lspService.hover(filePath, lspLine, lspChar);
+						break;
+					case "documentSymbol":
+						result = await lspService.documentSymbol(filePath);
+						break;
+					case "workspaceSymbol":
+						result = await lspService.workspaceSymbol(query ?? "");
+						break;
+					case "implementation":
+						result = await lspService.implementation(
+							filePath,
+							lspLine,
+							lspChar,
+						);
+						break;
+					default:
+						result = [];
+				}
+			} catch (err) {
+				return {
+					content: [
+						{
+							type: "text" as const,
+							text: `LSP error: ${err instanceof Error ? err.message : String(err)}`,
+						},
+					],
+					isError: true,
+					details: {},
+				};
+			}
+
+			const isEmpty = !result || (Array.isArray(result) && result.length === 0);
+			const output = isEmpty
+				? `No results for ${operation} at ${path.basename(filePath)}${line ? `:${line}:${character}` : ""}`
+				: JSON.stringify(result, null, 2);
+
+			return {
+				content: [{ type: "text" as const, text: output }],
+				details: {
+					operation,
+					resultCount: Array.isArray(result) ? result.length : result ? 1 : 0,
+				},
+			};
+		},
+	});
+
 	let _cachedJscpdClones: import("./clients/jscpd-client.js").DuplicateClone[] =
 		[];
 	const cachedExports = new Map<string, string>(); // function name -> file path
@@ -593,11 +761,11 @@ export default function (pi: ExtensionAPI) {
 	> = new Map();
 
 	// Delta baselines: store pre-write diagnostics to diff against post-write
-	const astGrepBaselines = new Map<
+	const _astGrepBaselines = new Map<
 		string,
 		import("./clients/ast-grep-types.js").AstGrepDiagnostic[]
 	>();
-	const biomeBaselines = new Map<
+	const _biomeBaselines = new Map<
 		string,
 		import("./clients/biome-client.js").BiomeDiagnostic[]
 	>();
@@ -709,8 +877,8 @@ export default function (pi: ExtensionAPI) {
 		dbg(`session_start TODO scan: ${todoResult.items.length} items`);
 		if (todoReport) parts.push(todoReport);
 
-		// Dead code scan — use cache if fresh
-		if (knipClient.isAvailable()) {
+		// Dead code scan — use cache if fresh, auto-install if needed
+		if (await knipClient.ensureAvailable()) {
 			const cached = cacheManager.readCache<ReturnType<KnipClient["analyze"]>>(
 				"knip",
 				cwd,
@@ -735,8 +903,8 @@ export default function (pi: ExtensionAPI) {
 			dbg(`session_start Knip: not available`);
 		}
 
-		// Duplicate code detection — use cache if fresh
-		if (jscpdClient.isAvailable()) {
+		// Duplicate code detection — use cache if fresh, auto-install if needed
+		if (await jscpdClient.ensureAvailable()) {
 			const cached = cacheManager.readCache<ReturnType<JscpdClient["scan"]>>(
 				"jscpd",
 				cwd,
@@ -764,7 +932,7 @@ export default function (pi: ExtensionAPI) {
 		// Note: type-coverage runs on-demand via /lens-booboo only (not at session_start)
 
 		// Scan for exported functions (cached for duplicate detection on write)
-		if (astGrepClient.isAvailable()) {
+		if (await astGrepClient.ensureAvailable()) {
 			const exports = await astGrepClient.scanExports(cwd, "typescript");
 			dbg(`session_start exports scan: ${exports.size} functions found`);
 			for (const [name, file] of exports) {
@@ -846,12 +1014,14 @@ export default function (pi: ExtensionAPI) {
 
 		if (!filePath) return;
 
+		const _toolCallStart = Date.now();
 		dbg(
 			`tool_call fired for: ${filePath} (exists: ${nodeFs.existsSync(filePath)})`,
 		);
 		if (!nodeFs.existsSync(filePath)) return;
 
 		// Record complexity baseline for TS/JS files + capture history snapshot
+		const complexityBaselineStart = Date.now();
 		if (
 			complexityClient.isSupportedFile(filePath) &&
 			!complexityBaselines.has(filePath)
@@ -867,64 +1037,108 @@ export default function (pi: ExtensionAPI) {
 					linesOfCode: baseline.linesOfCode,
 				});
 			}
+			logLatency({
+				type: "phase",
+				toolName: event.toolName,
+				filePath,
+				phase: "complexity_baseline",
+				durationMs: Date.now() - complexityBaselineStart,
+				metadata: { hasBaseline: complexityBaselines.has(filePath) },
+			});
 		}
 
 		const hints: string[] = [];
+		let _preCheckDuration = 0;
 
 		if (/\.(ts|tsx|js|jsx)$/.test(filePath) && !pi.getFlag("no-lsp")) {
+			const tsPreCheckStart = Date.now();
 			tsClient.updateFile(filePath, nodeFs.readFileSync(filePath, "utf-8"));
 			const diags = tsClient.getDiagnostics(filePath);
-			const fixes = tsClient.getAllCodeFixes(filePath);
-			if (diags.length > 0) {
-				const errorDiags = diags.filter((d) => d.severity === 1);
-				if (errorDiags.length > 0) {
+			// Pass pre-computed diags to avoid a second getSemanticDiagnostics call (~1s on large files)
+			const fixes = tsClient.getAllCodeFixes(filePath, diags);
+			const errorDiags = diags.filter((d) => d.severity === 1);
+			if (errorDiags.length > 0) {
+				hints.push(
+					`⚠ Pre-write: file has ${errorDiags.length} TypeScript error(s):`,
+				);
+				// Show first 3 errors with quick fixes
+				for (const d of errorDiags.slice(0, 3)) {
+					const lineFixes = fixes.get(d.range.start.line);
+					const fixHint = lineFixes?.[0]?.description
+						? ` 💡 ${lineFixes[0].description}`
+						: "";
 					hints.push(
-						`⚠ Pre-write: file has ${errorDiags.length} TypeScript error(s):`,
+						`  L${d.range.start.line + 1}: ${d.message.split("\n")[0].substring(0, 80)}${fixHint}`,
 					);
-					// Show first 3 errors with quick fixes
-					for (const d of errorDiags.slice(0, 3)) {
-						const lineFixes = fixes.get(d.range.start.line);
-						const fixHint = lineFixes?.[0]?.description
-							? ` 💡 ${lineFixes[0].description}`
-							: "";
-						hints.push(
-							`  L${d.range.start.line + 1}: ${d.message.split("\n")[0].substring(0, 80)}${fixHint}`,
-						);
-					}
-					if (errorDiags.length > 3) {
-						hints.push(`  ... and ${errorDiags.length - 3} more errors`);
-					}
+				}
+				if (errorDiags.length > 3) {
+					hints.push(`  ... and ${errorDiags.length - 3} more errors`);
 				}
 			}
+			_preCheckDuration += Date.now() - tsPreCheckStart;
+			logLatency({
+				type: "phase",
+				toolName: event.toolName,
+				filePath,
+				phase: "ts_pre_check",
+				durationMs: Date.now() - tsPreCheckStart,
+				metadata: { errorCount: errorDiags.length, hintCount: hints.length },
+			});
 		}
 
-		// Snapshot baselines for delta mode (no pre-write hints — delta handles it)
-		if (!pi.getFlag("no-ast-grep") && astGrepClient.isAvailable()) {
-			const baselineDiags = astGrepClient.scanFile(filePath);
-			astGrepBaselines.set(filePath, baselineDiags);
-
-			// Add to TDR baseline
-			const initialTdr = baselineDiags
-				.filter((d) => d.ruleDescription?.grade !== undefined)
-				.reduce((acc, d) => acc + (d.ruleDescription?.grade ?? 0), 0);
-
-			metricsClient.recordBaseline(filePath, initialTdr);
-		} else {
-			metricsClient.recordBaseline(filePath);
+		// Unified LSP pre-write check (when --lens-lsp enabled)
+		// This provides pre-write hints for all LSP languages (TypeScript, Python, Go, Rust, etc.)
+		if (pi.getFlag("lens-lsp") && !pi.getFlag("no-lsp")) {
+			const lspPreCheckStart = Date.now();
+			const lspService = getLSPService();
+			lspService
+				.hasLSP(filePath)
+				.then(async (hasLSP) => {
+					if (hasLSP) {
+						const content = nodeFs.readFileSync(filePath, "utf-8");
+						await lspService.openFile(filePath, content);
+						await new Promise((r) => setTimeout(r, 300));
+						const diags = await lspService.getDiagnostics(filePath);
+						const errorDiags = diags.filter((d) => d.severity === 1);
+						if (errorDiags.length > 0) {
+							hints.push(
+								`⚠ Pre-write: ${errorDiags.length} LSP error(s) detected:`,
+							);
+							for (const d of errorDiags.slice(0, 3)) {
+								hints.push(
+									`  L${d.range?.start?.line ?? 0 + 1}: ${d.message.slice(0, 80)}`,
+								);
+							}
+							if (errorDiags.length > 3) {
+								hints.push(`  ... and ${errorDiags.length - 3} more`);
+							}
+						}
+						_preCheckDuration += Date.now() - lspPreCheckStart;
+						logLatency({
+							type: "phase",
+							toolName: event.toolName,
+							filePath,
+							phase: "lsp_pre_check",
+							durationMs: Date.now() - lspPreCheckStart,
+							metadata: { hasLSP, errorCount: errorDiags?.length ?? 0 },
+						});
+					}
+				})
+				.catch((err) => {
+					logLatency({
+						type: "phase",
+						toolName: event.toolName,
+						filePath,
+						phase: "lsp_pre_check",
+						durationMs: Date.now() - lspPreCheckStart,
+						status: "failed",
+						metadata: { error: String(err) },
+					});
+				});
 		}
 
-		if (
-			!pi.getFlag("no-biome") &&
-			biomeClient.isAvailable() &&
-			biomeClient.isSupportedFile(filePath)
-		) {
-			biomeBaselines.set(
-				filePath,
-				biomeClient
-					.checkFile(filePath)
-					.filter((d) => d.category === "lint" || d.severity === "error"),
-			);
-		}
+		// Note: ast-grep baseline removed - we use ast-grep-napi in dispatch instead
+		// Note: biome baseline removed - auto-fix handles this in post-write
 
 		// Architectural rules: Skip pre-write hints (too noisy)
 		// Post-write violations will be shown via architect runner in dispatch
@@ -989,6 +1203,22 @@ export default function (pi: ExtensionAPI) {
 			);
 			return;
 		}
+
+		// --- FileTime assert: prevent stale writes (file modified since agent read it) ---
+		const sessionFileTime = createFileTime("default");
+		try {
+			sessionFileTime.assert(filePath);
+		} catch (err: unknown) {
+			if (err instanceof FileTimeError) {
+				// File was modified externally or never read - warn but don't block (for now)
+				// In strict mode this could block; currently we just surface the warning
+				const warning = `⚠️ FileTime warning: ${err.message}`;
+				dbg(warning);
+				// Don't return - let the operation proceed with warning
+			}
+		}
+		// Record this write so future assertions know the agent has the current state
+		sessionFileTime.read(filePath);
 		dbg(
 			`tool_result: tracking turn state for ${event.toolName} on ${filePath}`,
 		);
@@ -1156,7 +1386,7 @@ export default function (pi: ExtensionAPI) {
 			// Python: Ruff auto-fix (enabled by default)
 			if (
 				!noAutofixRuff &&
-				ruffClient.isAvailable() &&
+				(await ruffClient.ensureAvailable()) &&
 				ruffClient.isPythonFile(filePath)
 			) {
 				const result = ruffClient.fixFile(filePath);
@@ -1266,56 +1496,110 @@ export default function (pi: ExtensionAPI) {
 		}
 		phaseEnd("test_runner", { found: testInfoFound, ran: testRunnerRan });
 
-		// --- TypeScript Language Service diagnostics (post-write) ---
-		phaseStart("typescript_lsp");
-		// Fast semantic analysis for type errors, unused vars, etc.
-		if (filePath.endsWith(".ts") || filePath.endsWith(".tsx")) {
-			try {
-				const tsClient = new TypeScriptClient();
-
-				// Track the file in the language service
-				tsClient.addFile(filePath, fileContent || "");
-
-				// Get diagnostics (syntactic + semantic)
-				const diagnostics = tsClient.getDiagnostics(filePath);
-
-				if (diagnostics.length > 0) {
-					// Filter to most important diagnostics
-					const importantDiags = diagnostics.filter((d) => {
-						// Focus on errors and important warnings
-						// Skip noisy ones like "cannot find name" from missing imports
-						const code = (d as any).code;
-						if (code === 2304) return false; // "Cannot find name"
-						if (code === 2307) return false; // "Cannot find module"
-						// DiagnosticSeverity.Error = 1, Warning = 2
-						return d.severity === 1 || (d.severity === 2 && !code);
-					});
-
-					if (importantDiags.length > 0) {
-						const tsOutput = importantDiags
-							.slice(0, 5)
-							.map((d) => {
-								// DiagnosticSeverity.Error = 1
-								const severity = d.severity === 1 ? "🔴" : "🟡";
-								return `  ${severity} [TS${(d as any).code}] ${d.message.split("\n")[0]}`;
-							})
-							.join("\n");
-						lspOutput += `\n\n📐 TypeScript Diagnostics:\n${tsOutput}`;
-					}
+		// Note: TypeScript diagnostics are handled by the ts-lsp dispatch runner above.
+		// No inline TypeScriptClient check here — dispatch already covers it.
+
+		// --- Complexity tracking (post-write) ---
+		phaseStart("complexity_check");
+		if (complexityClient.isSupportedFile(filePath)) {
+			const oldBaseline = complexityBaselines.get(filePath);
+			const newComplexity = complexityClient.analyzeFile(filePath);
+			if (oldBaseline && newComplexity) {
+				const complexityDelta = {
+					cognitive:
+						newComplexity.cognitiveComplexity - oldBaseline.cognitiveComplexity,
+					maintainability:
+						newComplexity.maintainabilityIndex -
+						oldBaseline.maintainabilityIndex,
+					lines: newComplexity.linesOfCode - oldBaseline.linesOfCode,
+				};
+				// Warn if complexity significantly increased
+				if (
+					complexityDelta.cognitive > 3 ||
+					complexityDelta.maintainability < -5
+				) {
+					lspOutput += `\n\n⚠️ Complexity increased: +${complexityDelta.cognitive} cognitive, ${complexityDelta.maintainability.toFixed(1)} maintainability`;
 				}
-			} catch (err) {
-				dbg(`typescript-client error: ${err}`);
+				phaseEnd("complexity_check", {
+					delta: complexityDelta,
+					warned:
+						complexityDelta.cognitive > 3 ||
+						complexityDelta.maintainability < -5,
+				});
+			} else {
+				phaseEnd("complexity_check", { delta: null, warned: false });
 			}
+		} else {
+			phaseEnd("complexity_check", { skipped: true });
 		}
-		phaseEnd("typescript_lsp", {
-			isTsFile: filePath.endsWith(".ts") || filePath.endsWith(".tsx"),
-		});
 
 		// Agent behavior warnings (blind writes, thrashing)
 		if (behaviorWarnings.length > 0) {
 			lspOutput += `\n\n${agentBehaviorClient.formatWarnings(behaviorWarnings)}`;
 		}
 
+		// --- Cascade diagnostics: check other files for errors (when --lens-lsp) ---
+		if (pi.getFlag("lens-lsp") && !pi.getFlag("no-lsp")) {
+			const MAX_CASCADE_FILES = 5;
+			const MAX_DIAGNOSTICS_PER_FILE = 20;
+			const cascadeStart = Date.now();
+
+			try {
+				const lspService = getLSPService();
+				const allDiags = await lspService.getAllDiagnostics();
+				const normalizedEditedPath = path.resolve(filePath);
+				const otherFileErrors: Array<{
+					file: string;
+					errors: import("./clients/lsp/client.js").LSPDiagnostic[];
+				}> = [];
+
+				for (const [diagPath, diags] of allDiags) {
+					if (path.resolve(diagPath) === normalizedEditedPath) continue; // Skip edited file (dispatch already covered it)
+					const errors = diags.filter((d) => d.severity === 1);
+					if (errors.length > 0) {
+						otherFileErrors.push({ file: diagPath, errors });
+					}
+				}
+
+				if (otherFileErrors.length > 0) {
+					lspOutput += `\n\n📐 Cascade errors detected in ${otherFileErrors.length} other file(s):`;
+					for (const { file, errors } of otherFileErrors.slice(
+						0,
+						MAX_CASCADE_FILES,
+					)) {
+						const limited = errors.slice(0, MAX_DIAGNOSTICS_PER_FILE);
+						const suffix =
+							errors.length > MAX_DIAGNOSTICS_PER_FILE
+								? `\n... and ${errors.length - MAX_DIAGNOSTICS_PER_FILE} more`
+								: "";
+						// Structured XML format (like OpenCode) for cleaner parsing
+						lspOutput += `\n<diagnostics file="${file}">`;
+						for (const e of limited) {
+							const line = (e.range?.start?.line ?? 0) + 1;
+							const col = (e.range?.start?.character ?? 0) + 1;
+							const code = e.code ? ` [${e.code}]` : "";
+							lspOutput += `\n  ${code} (${line}:${col}) ${e.message.split("\n")[0].slice(0, 100)}`;
+						}
+						lspOutput += `${suffix}\n</diagnostics>`;
+					}
+					if (otherFileErrors.length > MAX_CASCADE_FILES) {
+						lspOutput += `\n... and ${otherFileErrors.length - MAX_CASCADE_FILES} more files with errors`;
+					}
+				}
+
+				logLatency({
+					type: "phase",
+					toolName,
+					filePath,
+					phase: "cascade_diagnostics",
+					durationMs: Date.now() - cascadeStart,
+					metadata: { filesWithErrors: otherFileErrors.length },
+				});
+			} catch (err) {
+				dbg(`cascade diagnostics error: ${err}`);
+			}
+		}
+
 		// LATENCY TRACKING: Log timing before returning
 		const elapsed = Date.now() - toolResultStart;
 		phaseEnd("total", { hasOutput: !!lspOutput });
@@ -1419,7 +1703,7 @@ export default function (pi: ExtensionAPI) {
 		}
 
 		// madge: only check files where imports changed
-		if (depChecker.isAvailable()) {
+		if (await depChecker.ensureAvailable()) {
 			const madgeFiles = cacheManager.getFilesForMadge(cwd);
 			if (madgeFiles.length > 0) {
 				dbg(

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "pi-lens",
-	"version": "3.1.2",
+	"version": "3.2.0",
 	"type": "module",
 	"description": "pi extension for real-time code quality — 31 LSP servers, tree-sitter structural analysis, AST pattern matching, auto-install for TypeScript/Python tooling, duplicate detection, complexity metrics, and inline blockers with comprehensive /lens-booboo reports",
 	"repository": {
@@ -56,6 +56,7 @@
 	},
 	"devDependencies": {
 		"@ast-grep/napi": "^0.42.0",
+		"@biomejs/biome": "^2.4.10",
 		"@types/node": "^22.10.5",
 		"js-yaml": "^4.1.1",
 		"typescript": "^5.0.0",

package/rules/tree-sitter-queries/tsx/no-nested-links.yml

@@ -0,0 +1,45 @@
+# Nested Anchor Tags Detection
+# Detects nested <a> tags which are invalid HTML
+id: no-nested-links
+name: Nested anchor tags
+severity: error
+category: correctness
+language: tsx
+
+message: "Nested <a> tags are invalid HTML and cause unexpected behavior"
+
+description: |
+  HTML does not allow anchor tags nested inside other anchor tags.
+  This causes rendering issues and unpredictable click behavior.
+
+query: |
+  (jsx_element
+    open_tag: (jsx_opening_element
+      (identifier) @OUTER
+      (#eq? @OUTER "a"))
+    (jsx_element
+      open_tag: (jsx_opening_element
+        (identifier) @INNER
+        (#eq? @INNER "a"))))
+
+metavars:
+  - OUTER
+  - INNER
+
+tags:
+  - correctness
+  - react
+  - jsx
+  - html
+
+examples:
+  bad: |
+    <a href="/outer">
+      <a href="/inner">Click</a>
+    </a>
+
+  good: |
+    <a href="/outer">Outer link</a>
+    <a href="/inner">Inner link</a>
+
+has_fix: false