@oh-my-pi/pi-coding-agent 15.3.2 → 15.4.2

package/src/hashline/parser.ts

@@ -1,246 +0,0 @@
-import { ABORT_MARKER, ABORT_WARNING, BEGIN_PATCH_MARKER, END_PATCH_MARKER, RANGE_INTERIOR_HASH } from "./constants";
-import {
-	computeLineHash,
-	describeAnchorExamples,
-	HL_BODY_SEP_RE_RAW,
-	HL_FILE_PREFIX,
-	HL_HASH_CAPTURE_RE_RAW,
-	HL_OP_CHARS,
-	HL_OP_INSERT_AFTER,
-	HL_OP_INSERT_BEFORE,
-	HL_OP_REPLACE,
-} from "./hash";
-import type { Anchor, HashlineCursor, HashlineEdit } from "./types";
-
-// Leniently accept anchors copied from read/search output:
-//   - optional leading line-marker decoration (`*`, `>`, `+`, `-`)
-//   - the required `LINE+HASH`
-//   - an optional trailing `|TEXT` body (or anything after the hash) so users
-//     can paste a full `LINE+HASH|TEXT` line verbatim.
-const LID_CAPTURE_RE = new RegExp(`^\\s*[>+\\-*]*\\s*${HL_HASH_CAPTURE_RE_RAW}(?:\\|.*)?\\s*$`);
-const regexEscape = (str: string): string => str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-
-function parseLid(raw: string, lineNum: number): Anchor {
-	const match = LID_CAPTURE_RE.exec(raw);
-	if (!match) {
-		throw new Error(
-			`line ${lineNum}: expected a full anchor such as ${describeAnchorExamples("119")}; ` +
-				`got ${JSON.stringify(raw)}.`,
-		);
-	}
-	return { line: Number.parseInt(match[1], 10), hash: match[2] };
-}
-
-interface ParsedRange {
-	start: Anchor;
-	end: Anchor;
-}
-
-function parseRange(raw: string, lineNum: number): ParsedRange {
-	if (!raw.includes("..")) {
-		const start = parseLid(raw, lineNum);
-		return { start, end: { ...start } };
-	}
-	const [startRaw, endRaw, extra] = raw.split("..");
-	if (extra !== undefined || !startRaw || !endRaw) {
-		throw new Error(
-			`line ${lineNum}: range must include exactly two full anchors separated by "..". ` +
-				`For a one-line edit, repeat the same anchor on both sides.`,
-		);
-	}
-	const start = parseLid(startRaw, lineNum);
-	const end = parseLid(endRaw, lineNum);
-	if (end.line < start.line) {
-		throw new Error(`line ${lineNum}: range ${startRaw}..${endRaw} ends before it starts.`);
-	}
-	if (end.line === start.line && end.hash !== start.hash) {
-		throw new Error(`line ${lineNum}: range ${startRaw}..${endRaw} uses two different hashes for the same line.`);
-	}
-	return { start, end };
-}
-
-function expandRange(range: ParsedRange): Anchor[] {
-	const anchors: Anchor[] = [];
-	for (let line = range.start.line; line <= range.end.line; line++) {
-		const hash =
-			line === range.start.line ? range.start.hash : line === range.end.line ? range.end.hash : RANGE_INTERIOR_HASH;
-		anchors.push({ line, hash });
-	}
-	return anchors;
-}
-
-function parseInsertTarget(raw: string, lineNum: number, kind: "before" | "after"): HashlineCursor {
-	if (raw === "BOF") return { kind: "bof" };
-	if (raw === "EOF") return { kind: "eof" };
-	const cursorKind = kind === "before" ? "before_anchor" : "after_anchor";
-	return { kind: cursorKind, anchor: parseLid(raw, lineNum) };
-}
-
-/**
- * Decide how to interpret the optional `|TEXT` body captured on an insert
- * op line:
- *   - For BOF/EOF cursors the body is always treated as an inline payload
- *     line (there's no anchor hash to compare against).
- *   - For anchored cursors, compute the hash of TEXT at the anchor's line
- *     number. If it matches the anchor's hash, the body is just a verbatim
- *     copy of the anchored line — discard it, payload must come from the
- *     following lines as usual.
- *   - Otherwise the body is the first (or only) payload line for this op.
- */
-function resolveInlineInsertBody(cursor: HashlineCursor, body: string | undefined): string | undefined {
-	if (body === undefined) return undefined;
-	if (cursor.kind !== "before_anchor" && cursor.kind !== "after_anchor") return body;
-	const { line, hash } = cursor.anchor;
-	if (computeLineHash(line, body) === hash) return undefined;
-	return body;
-}
-
-// Insert ops leniently accept a trailing `|TEXT` body on the op line itself
-// (e.g. `»502zk|\tconst foo = ...`). The anchor token excludes `|` so the body
-// is captured separately; resolveInlineInsertBody decides whether to treat the
-// captured text as a verbatim anchor decoration (when its hash matches the
-// anchor's) or as an inline payload line.
-const INSERT_BEFORE_OP_RE = new RegExp(
-	`^${regexEscape(HL_OP_INSERT_BEFORE)}\\s*([^|\\s]+)(?:${HL_BODY_SEP_RE_RAW}(.*))?\\s*$`,
-);
-const INSERT_AFTER_OP_RE = new RegExp(
-	`^${regexEscape(HL_OP_INSERT_AFTER)}\\s*([^|\\s]+)(?:${HL_BODY_SEP_RE_RAW}(.*))?\\s*$`,
-);
-const REPLACE_OP_RE = new RegExp(`^${regexEscape(HL_OP_REPLACE)}\\s*([^\\s+<\\-=]\\S*)\\s*$`);
-
-function isEnvelopeOrAbortMarkerLine(line: string): boolean {
-	const trimmed = line.trimEnd();
-	return trimmed === BEGIN_PATCH_MARKER || trimmed === END_PATCH_MARKER || trimmed === ABORT_MARKER;
-}
-
-function isPayloadTerminatorLine(line: string): boolean {
-	const first = line[0];
-	return (
-		first === HL_FILE_PREFIX ||
-		(first !== undefined && HL_OP_CHARS.includes(first)) ||
-		isEnvelopeOrAbortMarkerLine(line)
-	);
-}
-
-export function cloneCursor(cursor: HashlineCursor): HashlineCursor {
-	if (cursor.kind === "before_anchor") return { kind: "before_anchor", anchor: { ...cursor.anchor } };
-	if (cursor.kind === "after_anchor") return { kind: "after_anchor", anchor: { ...cursor.anchor } };
-	return cursor;
-}
-
-function collectPayload(
-	lines: string[],
-	startIndex: number,
-	opLineNum: number,
-	requirePayload: boolean,
-): { payload: string[]; nextIndex: number } {
-	const payload: string[] = [];
-	let index = startIndex;
-	while (index < lines.length) {
-		const line = lines[index];
-		if (isPayloadTerminatorLine(line)) break;
-		payload.push(line);
-		index++;
-	}
-	if (payload.length === 0 && requirePayload) {
-		throw new Error(
-			`line ${opLineNum}: ${HL_OP_INSERT_BEFORE} and ${HL_OP_INSERT_AFTER} operations require at least one verbatim payload line.`,
-		);
-	}
-	return { payload, nextIndex: index };
-}
-
-export function parseHashline(diff: string): HashlineEdit[] {
-	return parseHashlineWithWarnings(diff).edits;
-}
-
-export function parseHashlineWithWarnings(diff: string): { edits: HashlineEdit[]; warnings: string[] } {
-	const edits: HashlineEdit[] = [];
-	const warnings: string[] = [];
-	const lines = diff.split(/\r?\n/);
-	if (diff.endsWith("\n") && lines.at(-1) === "") lines.pop();
-	let editIndex = 0;
-
-	const pushInsert = (cursor: HashlineCursor, text: string, lineNum: number) => {
-		edits.push({ kind: "insert", cursor: cloneCursor(cursor), text, lineNum, index: editIndex++ });
-	};
-
-	for (let i = 0; i < lines.length; ) {
-		const lineNum = i + 1;
-		const line = lines[i];
-
-		if (line.trim().length === 0) {
-			i++;
-			continue;
-		}
-		if (line === END_PATCH_MARKER) {
-			break;
-		}
-		if (line === ABORT_MARKER) {
-			warnings.push(ABORT_WARNING);
-			break;
-		}
-		if (line === BEGIN_PATCH_MARKER) {
-			i++;
-			continue;
-		}
-
-		const insertBeforeMatch = INSERT_BEFORE_OP_RE.exec(line);
-		if (insertBeforeMatch) {
-			const cursor = parseInsertTarget(insertBeforeMatch[1], lineNum, "before");
-			const inlineBody = resolveInlineInsertBody(cursor, insertBeforeMatch[2]);
-			const { payload, nextIndex } = collectPayload(lines, i + 1, lineNum, inlineBody === undefined);
-			if (inlineBody !== undefined) pushInsert(cursor, inlineBody, lineNum);
-			for (const text of payload) pushInsert(cursor, text, lineNum);
-			i = nextIndex;
-			continue;
-		}
-
-		const insertAfterMatch = INSERT_AFTER_OP_RE.exec(line);
-		if (insertAfterMatch) {
-			const cursor = parseInsertTarget(insertAfterMatch[1], lineNum, "after");
-			const inlineBody = resolveInlineInsertBody(cursor, insertAfterMatch[2]);
-			const { payload, nextIndex } = collectPayload(lines, i + 1, lineNum, inlineBody === undefined);
-			if (inlineBody !== undefined) pushInsert(cursor, inlineBody, lineNum);
-			for (const text of payload) pushInsert(cursor, text, lineNum);
-			i = nextIndex;
-			continue;
-		}
-
-		const replaceMatch = REPLACE_OP_RE.exec(line);
-		if (replaceMatch) {
-			const range = parseRange(replaceMatch[1], lineNum);
-			const { payload, nextIndex } = collectPayload(lines, i + 1, lineNum, false);
-			if (payload.length > 0) {
-				for (const text of payload) {
-					edits.push({
-						kind: "insert",
-						cursor: { kind: "before_anchor", anchor: { ...range.start } },
-						text,
-						lineNum,
-						index: editIndex++,
-					});
-				}
-			}
-			for (const anchor of expandRange(range)) {
-				edits.push({ kind: "delete", anchor, lineNum, index: editIndex++ });
-			}
-			i = nextIndex;
-			continue;
-		}
-
-		if (isPayloadTerminatorLine(line) || /^[-@\u00B6]/u.test(line)) {
-			throw new Error(
-				`line ${lineNum}: unrecognized op. Use ${HL_OP_INSERT_BEFORE}ANCHOR (insert before), ${HL_OP_INSERT_AFTER}ANCHOR (insert after), or ${HL_OP_REPLACE}A..B (replace/delete). ` +
-					`Got ${JSON.stringify(line)}.`,
-			);
-		}
-
-		throw new Error(
-			`line ${lineNum}: payload line has no preceding ${HL_OP_INSERT_BEFORE}, ${HL_OP_INSERT_AFTER}, or ${HL_OP_REPLACE} operation. ` +
-				`Got ${JSON.stringify(line)}.`,
-		);
-	}
-
-	return { edits, warnings };
-}

package/src/mcp/discoverable-tool-metadata.ts

@@ -1,24 +0,0 @@
-/**
- * Back-compat re-export layer.
- * All types and functions have moved to src/tool-discovery/tool-index.ts.
- * This file exists solely so existing imports continue to compile without changes.
- */
-export type {
-	DiscoverableMCPSearchDocument,
-	DiscoverableMCPSearchIndex,
-	DiscoverableMCPSearchResult,
-	DiscoverableMCPTool,
-	DiscoverableMCPToolServerSummary,
-	DiscoverableMCPToolSummary,
-} from "../tool-discovery/tool-index";
-
-export {
-	buildDiscoverableMCPSearchIndex,
-	collectDiscoverableMCPTools,
-	formatDiscoverableMCPToolServerSummary,
-	getDiscoverableMCPTool,
-	isMCPToolName,
-	searchDiscoverableMCPTools,
-	selectDiscoverableMCPToolNamesByServer,
-	summarizeDiscoverableMCPTools,
-} from "../tool-discovery/tool-index";

package/src/prompts/tools/vim.md

@@ -1,98 +0,0 @@
-Vim-style `edit` mode. The tool name stays `edit`; every call requires `file`, and the buffer loads automatically on first use.
-- `{"file": "path"}` - view file
-- `{"file": "path", "steps": [{"kbd": ["…"], "insert": "…"}]}` - edit file
-
-**Multi-location edits: always edit highest line number first (bottom-up).** Each insert shifts lines below it.
-
-## steps vs kbd vs insert
-
-`steps` = ordered editing steps. Each step runs `kbd`, then optionally types `insert`.
-`kbd` = Vim commands only (`dd`, `G`, `o`, `cc`, `gg`, etc.).
-`insert` = raw text content to type into the buffer.
-`o`/`O` already create a new line — do not start `insert` with `\n`. A trailing `\n` in `insert` adds an extra blank line.
-
-Never put text content in `kbd`. Only Vim keystrokes go there.
-- BAD: `{"steps": [{"kbd": ["1Gohello world<Esc>"]}]}`
-- BAD: `{"steps": [{"kbd": ["1Go", "hello world"]}]}`
-- BAD: `{"steps": [{"kbd": ["1Ao"], "insert": "text"}]}`
-- GOOD: `{"steps": [{"kbd": ["1Go"], "insert": "hello world"}]}`
-
-If a step uses `insert`, the last `kbd` entry in that step must leave INSERT mode active (`o`, `O`, `i`, `a`, `A`, `cc`, `C`, `s`, `S`).
-
-Each non-final `kbd` entry inside a step must end in NORMAL mode (add `<Esc>`).
-
-Between steps, the tool auto-exits INSERT mode.
-
-Whitespace in `kbd` is literal. Do not use spaces as separators between keys; `ggdGi` is one sequence, not `ggdG i`.
-
-Common mistake: `Ni` means "insert N copies", NOT "insert at line N". To insert at line N, use `NGo` (below) or `NGO` (above).
-## Editing patterns
-
-`NGo` = new line BELOW line N. `NGO` = new line ABOVE line N.
-
-Insert new line after line 3:
-```json
-{"file": "f.py", "steps": [{"kbd": ["3Go"], "insert": "    new line here"}]}
-```
-
-Insert new line before line 3:
-```json
-{"file": "f.py", "steps": [{"kbd": ["3GO"], "insert": "    new line here"}]}
-```
-
-Replace line N:
-```json
-{"file": "f.py", "steps": [{"kbd": ["5Gcc"], "insert": "    replacement content"}]}
-```
-
-Replace entire file. `ggdGi` = go to top, delete all, enter INSERT. Use that exact sequence when rewriting the whole file:
-```json
-{"file": "f.py", "steps": [{"kbd": ["ggdGi"], "insert": "entire new file content"}]}
-```
-
-Multi-location edit — edit **highest line number first** (bottom-up) so inserts don't shift later targets:
-```json
-{"file": "f.py", "steps": [
-  {"kbd": ["8Go"], "insert": "    print(result)"},
-  {"kbd": ["3Go"], "insert": "def helper(x):\n    return x + 1"}
-]}
-```
-Each `o`/`O` insert adds lines, shifting everything below. Bottom-up order keeps all line numbers valid. Use `\n` within `insert` for multi-line content.
-
-Navigation or search step without insert:
-```json
-{"file": "f.py", "steps": [{"kbd": ["/pattern<CR>"]}]}
-```
-
-Find and replace:
-```json
-{"file": "f.py", "steps": [{"kbd": [":%s/old/new/g<CR>"]}]}
-```
-
-Delete line range:
-```json
-{"file": "f.py", "steps": [{"kbd": [":3,5d<CR>"]}]}
-```
-Ex commands always start with `:` and end with `<CR>`. `3,5d` without `:` is NOT an ex command — it is interpreted as normal-mode keystrokes and will fail.
-
-## Undo mistakes
-- `{"file": "f.py", "steps": [{"kbd": ["u"]}]}` - undo last change
-- `{"file": "f.py", "steps": [{"kbd": ["3u"]}]}` - undo last 3 changes
-
-`:e!` reloads from disk. Warning: because non-paused calls auto-save, `:e!` reloads your last saved state, not the original file. Use `u` to undo instead. If stuck, use `ggdGi` with the full desired file content.
-
-## Session persistence
-
-The edit buffer in vim mode persists across tool calls. Cursor position, undo history, and file state are maintained until you close the buffer. Auto-save happens once after all steps in a non-paused call complete.
-
-## Supported
-
-Keys: `<Esc>` `<CR>` `<BS>` `<Tab>` `<C-d>` `<C-u>` `<C-r>` `<C-w>` `<C-o>`
-Motions: `h j k l <Space> w b e 0 $ ^ + - _ gg G { } f F t T % H M L ; ,` with counts
-Operators: `d c y p` with motions and text objects (`iw aw ip ap i" a" i( a( i{ a{`)
-Insert: `i a o O I A cc C s S R` - these all enter INSERT mode; do not add another `i` after them
-Visual: `v V` with `d y c > < ~ r u U p P o J`
-Other: `.` repeat, `u`/`<C-r>` undo/redo, `/pattern<CR>` search, `n N * #`, `gv` `gJ` `gU` `gu` `ZZ` `ZQ`
-Ex: `:w` `:q` `:wq` `:e` `:e!` `:N` `:s///` `:%s///` `:N,Md` `:%d` `:N,Mt N` `:sort` `:j` `:j!` `:g/pattern/d` `:v/pattern/d`
-Addresses: absolute line numbers, `.`, `$`, and `+N`/`-N` relative offsets, including ranges like `:.,$d` and `:.+2,$g/pattern/d`
-More ex: `:up` `:N,My` `:put` `:put!` `:N,Mco $` `:N,Mm $`