pi-readseek 0.7.6 → 0.7.8

package/src/register-tool.ts

@@ -1,29 +0,0 @@
-import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
-import { Type } from "@sinclair/typebox";
-
-/**
- * Optional tool parameter accepting an integer or its string form, since models
- * frequently pass integers as quoted strings. Both union halves share
- * {@link description}.
- */
-export function optionalIntOrString(description: string) {
-  return Type.Optional(Type.Union([Type.Number({ description }), Type.String({ description })]));
-}
-
-/** Required file-path parameter shared by the read, edit, and write tools. */
-export function filePathParam() {
-  return Type.String({ description: "Absolute or relative file path" });
-}
-
-/** Optional structural-map toggle shared by the read and write tools. */
-export function mapParam() {
-  return Type.Optional(Type.Boolean({ description: "Append structural map" }));
-}
-
-type ToolSpec = Parameters<ExtensionAPI["registerTool"]>[0];
-
-/** Register a readseek-backed tool definition. */
-export function registerReadSeekTool<T extends ToolSpec>(pi: ExtensionAPI, tool: T): T {
-  pi.registerTool(tool);
-  return tool;
-}

package/src/rename.ts

@@ -1,182 +0,0 @@
-import type { ExtensionAPI, ToolRenderResultOptions } from "@earendil-works/pi-coding-agent";
-import { Type } from "@sinclair/typebox";
-import path from "node:path";
-import { Text } from "@earendil-works/pi-tui";
-
-import { defineToolPromptMetadata } from "./tool-prompt-metadata.js";
-import { buildToolErrorResult } from "./readseek-value.js";
-import { resolveToCwd } from "./path-utils.js";
-import { classifyReadSeekFailure, readSeekRename, type RenameOutput } from "./readseek-client.js";
-import { filePathParam, registerReadSeekTool } from "./register-tool.js";
-import type { FileMutatedCallback } from "./tool-types.js";
-
-import { clampLineToWidth, clampLinesToWidth, linkedPathLine, linkToolPath, renderErrorResult, renderPendingResult, resolveRenderResultContext, summaryLine } from "./tui-render-utils.js";
-
-const RENAME_PROMPT_METADATA = defineToolPromptMetadata({
-	promptUrl: new URL("../prompts/rename.md", import.meta.url),
-	promptSnippet: "Rename the symbol at a cursor without touching shadows",
-});
-
-const renameSchema = Type.Object({
-	path: filePathParam(),
-	line: Type.Integer({ minimum: 1, description: "One-based line of the symbol to rename" }),
-	column: Type.Optional(Type.Integer({ minimum: 1, description: "One-based byte column for disambiguation" })),
-	to: Type.String({ description: "New symbol name" }),
-	workspace: Type.Optional(Type.Boolean({ description: "Rename across the project" })),
-	apply: Type.Optional(Type.Boolean({ description: "Apply the verified edits; default true" })),
-});
-
-interface RenameParams {
-	path: string;
-	line: number;
-	column?: number;
-	to: string;
-	workspace?: boolean;
-	apply?: boolean;
-}
-
-export interface ExecuteRenameOptions {
-	params: unknown;
-	signal: AbortSignal | undefined;
-	cwd: string;
-	onFileMutated?: FileMutatedCallback;
-}
-
-export async function executeRename(opts: ExecuteRenameOptions): Promise<any> {
-	const { params, signal, cwd, onFileMutated } = opts;
-	const p = params as RenameParams;
-
-	if (!p.to.trim()) {
-		return buildToolErrorResult("rename", "invalid-parameter", "rename parameter 'to' must not be empty");
-	}
-	if (!Number.isSafeInteger(p.line) || p.line < 1) {
-		return buildToolErrorResult("rename", "invalid-parameter", "rename parameter 'line' must be a positive integer");
-	}
-	if (p.column !== undefined && (!Number.isSafeInteger(p.column) || p.column < 1)) {
-		return buildToolErrorResult("rename", "invalid-parameter", "rename parameter 'column' must be a positive integer");
-	}
-
-	const filePath = resolveToCwd(p.path, cwd);
-
-	try {
-		const output = await readSeekRename(filePath, {
-			to: p.to,
-			line: p.line,
-			column: p.column,
-			workspace: p.workspace ? cwd : undefined,
-			apply: p.apply ?? true,
-			signal,
-		});
-		if (output.applied) {
-			for (const file of [output, ...output.others]) {
-				if (file.edits.length === 0) continue;
-				const absoluteFile = path.isAbsolute(file.file) ? file.file : path.resolve(cwd, file.file);
-				onFileMutated?.(absoluteFile);
-			}
-		}
-
-		const files: string[] = [output.file];
-		for (const other of output.others) {
-			const abs = path.isAbsolute(other.file) ? other.file : path.resolve(cwd, other.file);
-			if (!files.includes(abs)) files.push(abs);
-		}
-
-		const totalEdits = output.edits.length + output.others.reduce((sum, o) => sum + o.edits.length, 0);
-		const totalConflicts = output.conflicts.length + output.others.reduce((sum, o) => sum + o.conflicts.length, 0);
-
-		const parts: string[] = [];
-		if (totalConflicts > 0) {
-			parts.push(`${totalConflicts} naming conflict(s)`);
-		}
-		parts.push(`renamed ${output.old_name} to ${output.new_name} in ${totalEdits} location(s) across ${files.length} file(s)`);
-
-		let text = parts.join("; ");
-		if (output.applied) text += " (applied)";
-		else text += " (dry-run)";
-
-		// Surface first conflict reason for visibility
-		const firstConflict = output.conflicts[0]
-			?? output.others.find((o) => o.conflicts.length > 0)?.conflicts[0];
-		if (firstConflict) {
-			text += `\nFirst conflict at ${firstConflict.line}:${firstConflict.column}: ${firstConflict.reason}`;
-		}
-
-		return {
-			content: [{ type: "text", text }],
-			details: {
-				readSeekValue: {
-					tool: "rename",
-					ok: true,
-					path: filePath,
-					output,
-				},
-			},
-		};
-	} catch (err: any) {
-		const failure = classifyReadSeekFailure(err);
-		return buildToolErrorResult("rename", failure.code, failure.message, failure.hint ? { hint: failure.hint } : {});
-	}
-}
-
-export function registerRenameTool(pi: ExtensionAPI, options: { onFileMutated?: FileMutatedCallback } = {}) {
-	registerReadSeekTool(pi, {
-		name: "readSeek_rename",
-		label: "Rename",
-		description: RENAME_PROMPT_METADATA.description,
-		promptSnippet: RENAME_PROMPT_METADATA.promptSnippet,
-		promptGuidelines: RENAME_PROMPT_METADATA.promptGuidelines,
-		parameters: renameSchema,
-		async execute(_toolCallId, params, signal, _onUpdate, ctx) {
-			return executeRename({ params, signal, cwd: ctx.cwd, onFileMutated: options.onFileMutated });
-		},
-		renderCall(args: any, theme: any, ...rest: any[]) {
-			const context = rest[0] ?? {};
-			const cwd = context.cwd ?? process.cwd();
-			const displayPath = typeof args?.path === "string" ? args.path : "?";
-			let text = theme.fg("toolTitle", theme.bold("rename"));
-			text += ` ${linkToolPath(theme.fg("accent", displayPath), displayPath, cwd)}`;
-			if (args?.to) text += theme.fg("dim", ` → ${args.to}`);
-			return new Text(clampLineToWidth(text, context.width), 0, 0);
-		},
-		renderResult(result: any, options: ToolRenderResultOptions, theme: any, ...rest: any[]) {
-			const { isPartial, isError, expanded, cwd, width } = resolveRenderResultContext(options, rest);
-
-			if (isPartial) return renderPendingResult("pending rename", width, theme);
-
-			const content = result.content?.[0];
-			const textContent = content?.type === "text" ? content.text : "";
-			const readSeekValue = (result.details as any)?.readSeekValue;
-			const output = readSeekValue?.output as RenameOutput | undefined;
-
-			if (isError || result.isError) {
-				return renderErrorResult(textContent, { expanded, width, fallback: "rename failed", theme });
-			}
-
-			const outputs = output ? [output, ...output.others] : [];
-			const editCount = outputs.reduce((total, file) => total + file.edits.length, 0);
-			const conflictCount = outputs.reduce((total, file) => total + file.conflicts.length, 0);
-			const fileCount = outputs.length;
-			const action = output?.applied
-				? `renamed ${output.old_name} → ${output.new_name}`
-				: `rename plan for ${output?.old_name ?? "?"} → ${output?.new_name ?? "?"} (dry-run)`;
-			const details = output
-				? ` • ${editCount} ${editCount === 1 ? "edit" : "edits"} in ${fileCount} ${fileCount === 1 ? "file" : "files"}`
-				: "";
-			const conflicts = conflictCount > 0 ? ` • ${conflictCount} ${conflictCount === 1 ? "conflict" : "conflicts"}` : "";
-			let text = summaryLine(`${action}${details}${conflicts}`, {
-				theme,
-				style: conflictCount > 0 ? "warning" : "success",
-			});
-
-			if (expanded && output) {
-				for (const file of outputs) {
-					const display = path.relative(cwd, file.file) || file.file;
-					text += `\n${linkedPathLine(theme, file.file, display, cwd, ` (${file.edits.length} edits)`, width)}`;
-				}
-			}
-
-			const lines = clampLinesToWidth(text.split("\n"), width);
-			return new Text(lines.join("\n"), 0, 0);
-		},
-	});
-}

package/src/replace-symbol.ts

@@ -1,77 +0,0 @@
-import { readSeekMapContent } from "./readseek-client.js";
-import { findSymbol } from "./readseek/symbol-lookup.js";
-import { formatAmbiguous, formatNotFound } from "./readseek/symbol-error-format.js";
-import { normalizeToLF } from "./edit-diff.js";
-
-interface ReplaceSymbolInput {
-	filePath: string;
-	content: string;
-	symbol: string;
-	newBody: string;
-}
-
-type ReplaceSymbolResult =
-	| { type: "ok"; content: string; replacement: string; warnings: string[]; range: { start: number; end: number } }
-	| { type: "not-found"; message: string }
-	| { type: "ambiguous"; message: string }
-	| { type: "unsupported"; message: string };
-
-function detectIndent(line: string): string {
-	return line.match(/^\s*/)?.[0] ?? "";
-}
-
-function dedent(text: string): string {
-	const lines = text.split("\n");
-	const nonEmpty = lines.filter((l) => l.trim().length);
-	if (!nonEmpty.length) return text;
-	const minIndent = Math.min(...nonEmpty.map((l) => l.match(/^\s*/)?.[0].length ?? 0));
-	return lines.map((l) => l.slice(minIndent)).join("\n");
-}
-
-function reindent(text: string, indent: string): string {
-	return text.split("\n").map((l) => (l.length ? indent + l : l)).join("\n");
-}
-
-export async function replaceSymbol(input: ReplaceSymbolInput): Promise<ReplaceSymbolResult> {
-	const map = await readSeekMapContent(input.filePath, input.content);
-	if (!map) {
-		return {
-			type: "unsupported",
-			message: `Unsupported file for replace_symbol: readseek could not map '${input.filePath}'. Use anchored edits for this file type.`,
-		};
-	}
-	const lookup = findSymbol(map, input.symbol);
-	if (lookup.type === "not-found") {
-		return { type: "not-found", message: formatNotFound(input.symbol, map) };
-	}
-	if (lookup.type === "ambiguous") {
-		return { type: "ambiguous", message: formatAmbiguous(input.symbol, lookup.candidates) };
-	}
-	const sym = lookup.symbol;
-	const lines = input.content.split("\n");
-	const sigLine = lines[sym.startLine - 1] ?? "";
-	const indent = detectIndent(sigLine);
-	const reindented = reindent(dedent(normalizeToLF(input.newBody)), indent);
-	const warnings: string[] = [];
-	const leaf = input.symbol.replace(/@\d+$/, "").split(".").pop() ?? "";
-	const declNameRe =
-		/\b(?:(?:export\s+(?:default\s+)?|async\s+|public\s+|private\s+|protected\s+|static\s+)*)(?:function\*?|class|const|let|var|fn|def|method|type|interface|enum)\s+([A-Za-z_$][\w$]*)/s;
-	const firstDeclName =
-		reindented.match(declNameRe)?.[1]
-		?? reindented.match(/^\s*(?:(?:async\s+)?[\w$<>,?\s]+\s+)?([A-Za-z_$][\w$]*)\s*\(/)?.[1];
-	if (leaf && firstDeclName && firstDeclName !== leaf) {
-		warnings.push(`name-mismatch: expected ${leaf}, got ${firstDeclName}`);
-	}
-	const before = lines.slice(0, sym.startLine - 1).join("\n");
-	const after = lines.slice(sym.endLine).join("\n");
-	const beforePart = before.length ? before + "\n" : "";
-	const afterPart = after.length ? "\n" + after : "";
-	const newContent = beforePart + reindented + afterPart;
-	return {
-		type: "ok",
-		content: newContent,
-		replacement: reindented,
-		warnings,
-		range: { start: sym.startLine, end: sym.endLine },
-	};
-}

package/src/runtime.ts

@@ -1,3 +0,0 @@
-export function throwIfAborted(signal?: AbortSignal): void {
-	if (signal?.aborted) throw new Error("Operation aborted");
-}

package/src/search-output.ts

@@ -1,50 +0,0 @@
-import { formatAnchoredFileBlocks, type ReadSeekLine, type ReadSeekRange } from "./readseek-value.js";
-
-export interface SearchOutputFile {
-  displayPath: string;
-  path: string;
-  ranges: ReadSeekRange[];
-  lines: ReadSeekLine[];
-  symbols?: Array<{ name: string; kind?: string }>;
-}
-
-export interface BuildSearchOutputInput {
-  pattern: string;
-  files: SearchOutputFile[];
-}
-
-export interface SearchOutputResult {
-  text: string;
-  readSeekValue: {
-    tool: "search";
-    files: Array<{
-      path: string;
-      ranges: ReadSeekRange[];
-      lines: ReadSeekLine[];
-    }>;
-  };
-}
-
-export function buildSearchOutput(input: BuildSearchOutputInput): SearchOutputResult {
-  if (input.files.length === 0) {
-    return {
-      text: `No matches found for pattern: ${input.pattern}`,
-      readSeekValue: {
-        tool: "search",
-        files: [],
-      },
-    };
-  }
-
-  return {
-    text: formatAnchoredFileBlocks(input.files),
-    readSeekValue: {
-      tool: "search",
-      files: input.files.map((file) => ({
-        path: file.path,
-        ranges: file.ranges.map((range) => ({ ...range })),
-        lines: file.lines.map((line) => ({ ...line })),
-      })),
-    },
-  };
-}

package/src/search.ts

@@ -1,214 +0,0 @@
-import path from "node:path";
-
-import type { ExtensionAPI, ToolRenderResultOptions } from "@earendil-works/pi-coding-agent";
-import { Type } from "@sinclair/typebox";
-
-import { defineToolPromptMetadata } from "./tool-prompt-metadata.js";
-import { buildReadSeekLineWithHash, buildToolErrorResult, type ReadSeekLine } from "./readseek-value.js";
-import { resolveToCwd } from "./path-utils.js";
-import { statSearchPathOrError } from "./stat-search-path.js";
-import { classifyReadSeekFailure, readSeekSearch, type ReadSeekSearchFileOutput } from "./readseek-client.js";
-import { buildSearchOutput } from "./search-output.js";
-import type { FileAnchoredCallback } from "./tool-types.js";
-import { langParam, readSeekGitSearchParams, searchPathParam, validateIgnoredRequiresOthers } from "./readseek-params.js";
-import { registerReadSeekTool } from "./register-tool.js";
-
-import { renderAnchoredFilesResult, renderReadSeekSearchCall } from "./tui-render-utils.js";
-
-type SearchParams = { pattern: string; lang?: string; path?: string; cached?: boolean; others?: boolean; ignored?: boolean };
-
-export interface SearchRange {
-  startLine: number;
-  endLine: number;
-}
-
-export interface SearchEnclosingSymbol {
-  name: string;
-  kind: string;
-}
-
-export function mergeRanges(ranges: SearchRange[]): SearchRange[] {
-  if (ranges.length === 0) return [];
-  if (ranges.length === 1) return [{ ...ranges[0] }];
-
-  const sorted = [...ranges].sort((a, b) => a.startLine - b.startLine);
-  const merged: SearchRange[] = [{ ...sorted[0] }];
-
-  for (let i = 1; i < sorted.length; i++) {
-    const current = sorted[i];
-    const last = merged[merged.length - 1];
-    if (current.startLine <= last.endLine + 2) {
-      last.endLine = Math.max(last.endLine, current.endLine);
-    } else {
-      merged.push({ ...current });
-    }
-  }
-
-  return merged;
-}
-
-const SEARCH_PROMPT_METADATA = defineToolPromptMetadata({
-  promptUrl: new URL("../prompts/search.md", import.meta.url),
-  promptSnippet: "Search syntax-aware code shapes with AST patterns",
-});
-
-interface SearchToolOptions {
-  onFileAnchored?: FileAnchoredCallback;
-}
-
-/**
- * Inputs for executing the structural search tool without registering it.
- */
-export interface ExecuteSearchOptions {
-  params: unknown;
-  signal: AbortSignal | undefined;
-  cwd: string;
-  onFileAnchored?: FileAnchoredCallback;
-}
-
-function linesFromSearchResult(result: ReadSeekSearchFileOutput, ranges: SearchRange[]): ReadSeekLine[] {
-  const lineMap = new Map<number, ReadSeekLine>();
-  for (const match of result.matches) {
-    for (const line of match.hashlines) {
-      lineMap.set(line.line, buildReadSeekLineWithHash(line.line, line.hash, line.text));
-    }
-  }
-
-  const lines: ReadSeekLine[] = [];
-  const seen = new Set<number>();
-  for (const range of ranges) {
-    for (let line = range.startLine; line <= range.endLine; line++) {
-      if (seen.has(line)) continue;
-      const readSeekLine = lineMap.get(line);
-      if (!readSeekLine) continue;
-      seen.add(line);
-      lines.push(readSeekLine);
-    }
-  }
-  return lines;
-}
-
-function readSeekLanguageForPath(language: string | undefined, searchPath: string, isFile: boolean): string | undefined {
-  if (language === "typescript" && isFile && path.extname(searchPath).toLowerCase() === ".tsx") return "tsx";
-  return language;
-}
-
-/**
- * Executes structural search and returns readseek-anchored matches.
- */
-export async function executeSearch(opts: ExecuteSearchOptions): Promise<any> {
-  const { params, signal, cwd, onFileAnchored } = opts;
-  const p = params as SearchParams;
-  const ignoredError = validateIgnoredRequiresOthers("search", p);
-  if (ignoredError) return ignoredError;
-  const searchPath = resolveToCwd(p.path ?? ".", cwd);
-
-  const statResult = await statSearchPathOrError("search", p.path, searchPath);
-  if (!statResult.ok) return statResult.error;
-  const searchPathIsFile = statResult.stats.isFile();
-
-  try {
-    const effectiveLang = readSeekLanguageForPath(p.lang, searchPath, searchPathIsFile);
-    const results = await readSeekSearch(searchPath, p.pattern, {
-      language: effectiveLang,
-      cached: p.cached,
-      others: p.others,
-      ignored: p.ignored,
-      signal,
-    });
-    if (results.length === 0) {
-      const emptyOutput = buildSearchOutput({ pattern: p.pattern, files: [] });
-      return {
-        content: [{ type: "text", text: emptyOutput.text }],
-        details: {
-          readSeekValue: emptyOutput.readSeekValue,
-        },
-      };
-    }
-
-    const readSeekFiles: Array<{
-      displayPath: string;
-      path: string;
-      ranges: SearchRange[];
-      lines: ReadSeekLine[];
-      symbols?: SearchEnclosingSymbol[];
-    }> = [];
-
-    for (const result of results) {
-      const abs = path.isAbsolute(result.file) ? result.file : path.resolve(cwd, result.file);
-      const display = path.relative(cwd, abs) || abs;
-      const ranges = result.matches.map((match) => ({ startLine: match.start_line, endLine: match.end_line }));
-      const mergedRanges = mergeRanges(ranges);
-      const lines = linesFromSearchResult(result, mergedRanges);
-      if (lines.length === 0) continue;
-      readSeekFiles.push({
-        displayPath: display,
-        path: abs,
-        ranges: mergedRanges.map((range) => ({ ...range })),
-        lines,
-      });
-    }
-
-    if (readSeekFiles.length === 0) {
-      const emptyOutput = buildSearchOutput({ pattern: p.pattern, files: [] });
-      return {
-        content: [{ type: "text", text: emptyOutput.text }],
-        details: {
-          readSeekValue: emptyOutput.readSeekValue,
-        },
-      };
-    }
-
-    const builtOutput = buildSearchOutput({
-      pattern: p.pattern,
-      files: readSeekFiles,
-    });
-    for (const readSeekFile of readSeekFiles) {
-      onFileAnchored?.(readSeekFile.path);
-    }
-    return {
-      content: [{ type: "text", text: builtOutput.text }],
-      details: {
-        readSeekValue: builtOutput.readSeekValue,
-      },
-    };
-  } catch (err: any) {
-    const failure = classifyReadSeekFailure(err);
-    return buildToolErrorResult("search", failure.code, failure.message, failure.hint ? { hint: failure.hint } : {});
-  }
-}
-
-export function registerSearchTool(pi: ExtensionAPI, options: SearchToolOptions = {}) {
-  const tool = registerReadSeekTool(pi, {
-    name: "readSeek_search",
-    label: "Structural Search",
-    description: SEARCH_PROMPT_METADATA.description,
-    promptSnippet: SEARCH_PROMPT_METADATA.promptSnippet,
-    promptGuidelines: SEARCH_PROMPT_METADATA.promptGuidelines,
-    parameters: Type.Object({
-      pattern: Type.String({ description: "ast-grep pattern, such as console.log($$$ARGS)" }),
-      lang: langParam(),
-      path: searchPathParam(),
-      ...readSeekGitSearchParams(),
-    }),
-    async execute(_toolCallId, params, signal, _onUpdate, ctx) {
-      return executeSearch({ params, signal, cwd: ctx.cwd, onFileAnchored: options.onFileAnchored });
-    },
-    renderCall(args: any, theme: any, ...rest: any[]) {
-      return renderReadSeekSearchCall(args, theme, rest, {
-        label: "search",
-        accent: `/${args.pattern}/`,
-        flags: [args.cached && "cached", args.others && "others", args.ignored && "ignored"],
-      });
-    },
-    renderResult(result: any, options: ToolRenderResultOptions, theme: any, ...rest: any[]) {
-      return renderAnchoredFilesResult(result, options, theme, rest, {
-        pendingLabel: "pending search",
-        emptyLabel: "no matches",
-        unitSingular: "match",
-        unitPlural: "matches",
-      });
-    },
-  });
-  return tool;
-}

package/src/session-anchors.ts

@@ -1,34 +0,0 @@
-/**
- * Tracks files that have fresh hashline anchors in the current extension session.
- */
-export class SessionAnchors {
-  readonly #paths = new Set<string>();
-
-  /**
-   * Records that a file has produced anchors usable by later edit calls.
-   */
-  markAnchored(absolutePath: string): void {
-    this.#paths.add(absolutePath);
-  }
-
-  /**
-   * Forgets anchors after a file mutation that did not return current anchors.
-   */
-  forget(absolutePath: string): void {
-    this.#paths.delete(absolutePath);
-  }
-
-  /**
-   * Forgets every anchor, such as when resetting extension session state.
-   */
-  clear(): void {
-    this.#paths.clear();
-  }
-
-  /**
-   * Returns whether a file has fresh anchors in the current session.
-   */
-  hasFreshAnchors(absolutePath: string): boolean {
-    return this.#paths.has(absolutePath);
-  }
-}

package/src/stat-search-path.ts

@@ -1,29 +0,0 @@
-import { stat as fsStat } from "node:fs/promises";
-import type { Stats } from "node:fs";
-
-import { buildToolErrorResult, type ToolErrorResult } from "./readseek-value.js";
-import { formatFsError } from "./fs-error.js";
-
-export type StatSearchPathResult =
-  | { ok: true; stats: Stats }
-  | { ok: false; error: ToolErrorResult };
-
-/**
- * Stat a tool's search path, mapping access failures into the shared readseek
- * error taxonomy. Used by refs and search, which reject a missing or
- * unreadable path with identical codes and messages.
- */
-export async function statSearchPathOrError(
-  tool: string,
-  rawPath: string | undefined,
-  searchPath: string,
-): Promise<StatSearchPathResult> {
-  try {
-    return { ok: true, stats: await fsStat(searchPath) };
-  } catch (err: any) {
-    const display = rawPath ?? ".";
-    const path = rawPath ?? searchPath;
-    const { code, message } = formatFsError(err, "stat-error");
-    return { ok: false, error: buildToolErrorResult(tool, code, message, { path }) };
-  }
-}

package/src/syntax-validate-mode.ts

@@ -1,15 +0,0 @@
-import { resolveReadSeekSyntaxValidation } from "./readseek-settings.js";
-
-export type SyntaxValidateMode = "warn" | "block" | "off";
-
-export interface SyntaxValidateOptions {
-  syntaxValidate?: SyntaxValidateMode;
-}
-
-const DEFAULT: SyntaxValidateMode = "warn";
-
-export function resolveSyntaxValidateMode(
-  opts: SyntaxValidateOptions,
-): SyntaxValidateMode {
-  return opts.syntaxValidate ?? resolveReadSeekSyntaxValidation() ?? DEFAULT;
-}