@adeildo/pi-ask-permission 4.1.0 → 5.1.0

package/src/ui/questions.ts

@@ -0,0 +1,194 @@
+// The permission ask, drawn by the questions feature so both dialogs are the same one. The call
+// becomes a question, and the answer becomes the decision the gate already knows how to apply.
+import { type AskAnswer, type AskOption, type AskQuestion, askQuestions } from "@adeildo/pi-kit";
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+
+import { SCOPE_LABEL, SCOPES, type Scope } from "#core/always-yes.ts";
+import type { DialogAnswer, FolderOffer } from "#core/answer.ts";
+import type { Call } from "#core/decide.ts";
+import { describeHints } from "#core/mcp.ts";
+import { openLabel } from "#ui/decision-options.ts";
+
+const YES = "yes, run it";
+const ALWAYS = "always yes";
+const DENY = "no";
+
+export interface AskExtras {
+	diff?: string;
+	reason?: string;
+	offer?: FolderOffer;
+}
+
+/** Undefined when the questions feature is not there to draw, or failed: the caller falls back. */
+export async function askThroughQuestions(
+	events: ExtensionAPI["events"],
+	call: Call,
+	extras: AskExtras,
+): Promise<DialogAnswer | undefined> {
+	const first = await askQuestions(events, [firstQuestion(call, extras)]);
+	if (first.error !== undefined) return undefined;
+	if (first.cancelled) return { decision: "deny" };
+
+	const answer = first.answers[0];
+	const note = noteOf(answer);
+	// A typed answer instead of a pick: the user is telling the model what to do instead.
+	if (answer === undefined || answer.picked.length === 0) return { decision: "deny", note };
+
+	const picked = answer.picked[0] ?? "";
+	if (picked === DENY) return { decision: "deny", note };
+	if (picked === ALWAYS) return remember(events, call, note);
+
+	const folder = folderOf(extras.offer, picked);
+	if (folder === undefined) return { decision: "allow", note };
+	const scope = await askScope(events, "Open the folder for how long?");
+	return { decision: "allow", note, open: { path: folder, access: extras.offer!.access, scope } };
+}
+
+function firstQuestion(call: Call, extras: AskExtras): AskQuestion {
+	const options: AskOption[] = [
+		{ label: YES, description: "Run this call now, and ask again next time." },
+		...(levelsOf(call).length > 0
+			? [
+					{
+						label: ALWAYS,
+						description: "Run this call, and stop asking for the calls you pick next.",
+					},
+				]
+			: []),
+		...offerOptions(extras.offer),
+		{
+			label: DENY,
+			description: "Block it. A note on this answer becomes the reason the model reads.",
+		},
+	];
+
+	// Every option offers the same preview, whichever row the cursor is on.
+	if (extras.diff !== undefined) for (const option of options) option.preview = extras.diff;
+
+	// The reason for a no is a note on it. A row of its own for words would say the same thing twice.
+	return {
+		header: "permission",
+		question: questionText(call, extras.reason),
+		options,
+		typed: false,
+	};
+}
+
+function offerOptions(offer: FolderOffer | undefined): { label: string; description: string }[] {
+	if (offer === undefined) return [];
+	const reads = offer.access === "read";
+	return [
+		{
+			label: openLabel(offer, offer.folders[offer.suggested] ?? ""),
+			description: reads
+				? "Run it, and let later calls read there without asking."
+				: "Run it, and treat that folder as part of the workspace.",
+		},
+	];
+}
+
+/** A heredoc or a long payload would fill the screen; a few lines say what the call is. */
+const SUMMARY_LINES = 3;
+
+function clipSummary(summary: string): string[] {
+	const lines = summary.split("\n");
+	if (lines.length <= SUMMARY_LINES) return lines;
+	const more = lines.length - SUMMARY_LINES;
+	return [...lines.slice(0, SUMMARY_LINES), `\u2026 ${more} more ${more === 1 ? "line" : "lines"}`];
+}
+
+function questionText(call: Call, reason: string | undefined): string {
+	const lines = [
+		`${whereOf(call)} wants to run:`,
+		...clipSummary(call.target.summary).map((line) => `  ${line}`),
+	];
+	if (reason !== undefined) lines.push("", `\u25b2 ${reason}`);
+	return lines.join("\n");
+}
+
+// The tool name, plus what it does not say: the server behind an MCP tool and what it declares, and
+// a call a script issued rather than the model.
+function whereOf(call: Call): string {
+	const parts: string[] = [];
+	if (call.mcp !== undefined)
+		parts.push(`${call.mcp.server}:${call.mcp.tool} (${describeHints(call.hints)})`);
+	else parts.push(call.toolName);
+	if (call.nested) parts.push("(from a codemode script)");
+	return parts.join(" ");
+}
+
+function levelsOf(call: Call): string[] {
+	return [...call.target.levels].toReversed();
+}
+
+/** The always-yes path: which calls to remember, then for how long. */
+async function remember(
+	events: ExtensionAPI["events"],
+	call: Call,
+	note: string | undefined,
+): Promise<DialogAnswer | undefined> {
+	const levels = levelsOf(call);
+	if (levels.length === 0) return { decision: "allow", note };
+
+	const picked = await askQuestions(events, [
+		{
+			header: "remember",
+			typed: false,
+			question: `Always say yes to which calls, from ${call.toolName}?`,
+			options: levels.map((level, index) => ({
+				label: level,
+				description:
+					index === 0
+						? "Only this exact call."
+						: "This call, and anything else that starts with it.",
+			})),
+		},
+	]);
+	if (picked.error !== undefined || picked.cancelled) return { decision: "allow", note };
+
+	const level = picked.answers[0]?.picked[0];
+	if (level === undefined || level === "") return { decision: "allow", note };
+	const scope = await askScope(events, "Remember it for how long?");
+	return { decision: "allow", note, remember: level, scope };
+}
+
+async function askScope(events: ExtensionAPI["events"], question: string): Promise<Scope> {
+	const result = await askQuestions(events, [
+		{
+			header: "where",
+			typed: false,
+			question,
+			options: SCOPES.map((scope) => ({
+				label: SCOPE_LABEL[scope],
+				description:
+					scope === "session"
+						? "Gone when this session ends."
+						: scope === "project"
+							? "Saved for this project, in its own file."
+							: "Saved for every project.",
+			})),
+		},
+	]);
+	const picked = result.answers[0]?.picked[0];
+	const scope = SCOPES.find((candidate) => SCOPE_LABEL[candidate] === picked);
+	return scope ?? "session";
+}
+
+function folderOf(offer: FolderOffer | undefined, picked: string): string | undefined {
+	if (offer === undefined) return undefined;
+	return offer.folders.find((folder) => openLabel(offer, folder) === picked);
+}
+
+/** Every note the user left, the picked option's first. */
+function noteOf(answer: AskAnswer | undefined): string | undefined {
+	if (answer === undefined) return undefined;
+	const parts: string[] = [];
+	const picked = answer.notes.find((note) => answer.picked.includes(note.option));
+	if (picked !== undefined) parts.push(picked.note);
+	for (const note of answer.notes)
+		if (!answer.picked.includes(note.option)) parts.push(`on "${note.option}": ${note.note}`);
+	const typed = answer.typed?.trim();
+	if (typed !== undefined && typed !== "") parts.push(typed);
+
+	return parts.length === 0 ? undefined : parts.join("\n");
+}

package/src/ui/selector.ts

@@ -1,20 +1,28 @@
 import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
 
 import { type Scope, SCOPE_LABEL, SCOPES } from "#core/always-yes.ts";
-import type { DialogAnswer } from "#core/answer.ts";
+import type { DialogAnswer, FolderOffer } from "#core/answer.ts";
 import type { CallDescriptor } from "#core/tools.ts";
-import { FALLBACK_CHOICES } from "#ui/decision-options.ts";
+import { fallbackChoices } from "#ui/decision-options.ts";
 
 export async function askViaSelector(
 	ctx: ExtensionContext,
 	toolName: string,
 	target: CallDescriptor,
+	offer?: FolderOffer,
 ): Promise<DialogAnswer> {
-	const labels = FALLBACK_CHOICES.map((option) => `${option.key}. ${option.label}`);
+	const choices = fallbackChoices(offer);
+	const labels = choices.map((option) => `${option.key}. ${option.label}`);
 	const choice = await ctx.ui.select(`Allow ${toolName}?\n${target.summary}`, labels);
-	const option = choice ? FALLBACK_CHOICES[labels.indexOf(choice)] : undefined;
+	const option = choice ? choices[labels.indexOf(choice)] : undefined;
 	if (!option) return { decision: "deny" };
 
+	const folder = offer?.folders[offer.suggested];
+	const open =
+		option.open && offer && folder !== undefined
+			? { path: folder, access: offer.access, scope: "session" as const }
+			: undefined;
+
 	let remember: string | undefined;
 	let scope: Scope | undefined;
 	if (option.always) {
@@ -38,5 +46,5 @@ export async function askViaSelector(
 		note = (await ctx.ui.input(prompt))?.trim() || undefined;
 	}
 
-	return { decision: option.decision, note, remember, scope };
+	return { decision: option.decision, note, remember, scope, open };
 }

package/src/ui/clipboard.ts

@@ -1,51 +0,0 @@
-import { randomUUID } from "node:crypto";
-import { writeFileSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-
-interface ClipboardImage {
-	bytes: Uint8Array;
-	mimeType: string;
-}
-
-interface ClipboardReader {
-	readClipboardImage: () => Promise<ClipboardImage | null>;
-	readClipboardText: () => Promise<string | null>;
-	extensionForImageMimeType: (mimeType: string) => string | null;
-}
-
-let loaded: Promise<ClipboardReader | null> | undefined;
-
-function loadClipboard(): Promise<ClipboardReader | null> {
-	loaded ??= (async () => {
-		try {
-			const root = import.meta.resolve("@earendil-works/pi-coding-agent");
-			const images = await import(new URL("./utils/clipboard-image.js", root).href);
-			const text = await import(new URL("./utils/clipboard.js", root).href);
-			return {
-				readClipboardImage: images.readClipboardImage,
-				extensionForImageMimeType: images.extensionForImageMimeType,
-				readClipboardText: text.readClipboardText,
-			};
-		} catch {
-			return null;
-		}
-	})();
-
-	return loaded;
-}
-
-export async function readClipboard(): Promise<string | null> {
-	const clipboard = await loadClipboard();
-	if (!clipboard) return null;
-
-	const image = await clipboard.readClipboardImage();
-	if (image) {
-		const extension = clipboard.extensionForImageMimeType(image.mimeType) ?? "png";
-		const path = join(tmpdir(), `pi-ask-permission-${randomUUID()}.${extension}`);
-		writeFileSync(path, Buffer.from(image.bytes));
-		return path;
-	}
-
-	return clipboard.readClipboardText();
-}

package/src/ui/dialog.ts

@@ -1,395 +0,0 @@
-import { renderDiff, type Theme } from "@earendil-works/pi-coding-agent";
-import {
-	type Component,
-	type Focusable,
-	Input,
-	Key,
-	type KeybindingsManager,
-	matchesKey,
-	truncateToWidth,
-	visibleWidth,
-	wrapTextWithAnsi,
-} from "@earendil-works/pi-tui";
-
-import { type Scope, SCOPE_LABEL, SCOPES } from "#core/always-yes.ts";
-import type { DialogAnswer } from "#core/answer.ts";
-import type { CallDescriptor } from "#core/tools.ts";
-import { readClipboard } from "#ui/clipboard.ts";
-import { CHOICES, type Choice } from "#ui/decision-options.ts";
-import {
-	cleanPaste,
-	expandPastes,
-	PASTE_END,
-	PASTE_START,
-	pasteMarker,
-	shouldCollapse,
-} from "#ui/paste.ts";
-
-type Phase = "menu" | "levels";
-
-const TITLE_PREFIX = "\u256d\u2500 ";
-const TITLE_SUFFIX = "\u256e";
-// The 1 is the space between the title and its dashes.
-const TITLE_CHROME_WIDTH = visibleWidth(TITLE_PREFIX) + 1 + visibleWidth(TITLE_SUFFIX);
-
-const SUMMARY_ROWS = 3;
-const DIFF_ROWS = 16;
-
-interface AskDialogOptions {
-	theme: Theme;
-	toolName: string;
-	target: CallDescriptor;
-	diff?: string;
-	keybindings: KeybindingsManager;
-	requestRender: () => void;
-	complete: (answer: DialogAnswer) => void;
-}
-
-export class AskDialog implements Component, Focusable {
-	private readonly theme: Theme;
-	private readonly toolName: string;
-	private readonly target: CallDescriptor;
-	private readonly diff: string | undefined;
-	private readonly requestRender: () => void;
-	private readonly complete: (answer: DialogAnswer) => void;
-	private readonly keybindings: KeybindingsManager;
-
-	private readonly noteInputs: Input[];
-
-	private readonly pastes = new Map<number, string>();
-	private pasteId = 0;
-	private pasteBuffer = "";
-
-	private phase: Phase = "menu";
-	private selected = 0;
-	private levelIndex = 0;
-	private scopeIndex = 0;
-	private pending: Choice | null = null;
-	private noteIndex: number | null = null;
-
-	private pendingNote: string | undefined;
-
-	private get activeNoteInput(): Input | undefined {
-		return this.noteIndex === null ? undefined : this.noteInputs[this.noteIndex];
-	}
-
-	private focusedFlag = false;
-	get focused(): boolean {
-		return this.focusedFlag;
-	}
-	set focused(value: boolean) {
-		this.focusedFlag = value;
-		for (const input of this.noteInputs) input.focused = value;
-	}
-
-	constructor(options: AskDialogOptions) {
-		this.theme = options.theme;
-		this.toolName = options.toolName;
-		this.target = options.target;
-		this.diff = options.diff;
-		this.requestRender = options.requestRender;
-		this.complete = options.complete;
-		this.keybindings = options.keybindings;
-
-		this.noteInputs = [...CHOICES.keys()].map((index) => {
-			const input = new Input({ prompt: "", placeholder: "" });
-			input.onSubmit = () => this.choose(index);
-			input.onEscape = () => {
-				this.noteIndex = null;
-			};
-			return input;
-		});
-	}
-
-	handleInput(data: string): void {
-		try {
-			this.dispatch(data);
-		} finally {
-			this.requestRender();
-		}
-	}
-
-	invalidate(): void {
-		for (const input of this.noteInputs) input.invalidate();
-	}
-
-	render(width: number): string[] {
-		const inner = Math.max(1, width - 4);
-		const lines: string[] = [...this.summaryLines(inner), ...this.diffLines()];
-		lines.push("");
-
-		if (this.phase === "levels") {
-			lines.push(...this.levelLines());
-		} else {
-			for (const [index, option] of CHOICES.entries()) {
-				lines.push(this.renderOption(option, index, inner));
-			}
-			lines.push("");
-			lines.push(
-				this.theme.fg(
-					"dim",
-					this.noteIndex === null
-						? "\u2191\u2193 or 1-3 pick   enter confirm   tab note   esc deny"
-						: "\u2191\u2193 pick   enter confirm   esc back",
-				),
-			);
-		}
-
-		return this.frame(lines, width, inner, `permission \u00b7 ${this.toolName}`);
-	}
-
-	private dispatch(data: string): void {
-		if (this.phase === "menu" && this.noteIndex !== null) {
-			if (matchesKey(data, Key.up)) this.moveNote(-1);
-			else if (matchesKey(data, Key.down)) this.moveNote(1);
-			else if (matchesKey(data, Key.tab)) this.noteIndex = null;
-			else this.handleNoteInput(data);
-			return;
-		}
-
-		if (this.phase === "levels") {
-			if (matchesKey(data, Key.up)) this.levelIndex = Math.max(0, this.levelIndex - 1);
-			else if (matchesKey(data, Key.down))
-				this.levelIndex = Math.min(this.target.levels.length - 1, this.levelIndex + 1);
-			else if (matchesKey(data, Key.tab)) this.scopeIndex = (this.scopeIndex + 1) % SCOPES.length;
-			else if (matchesKey(data, Key.enter)) this.confirmLevel();
-			else if (matchesKey(data, Key.escape)) this.phase = "menu";
-			return;
-		}
-
-		if (matchesKey(data, Key.up)) {
-			this.moveSelection(-1);
-			return;
-		}
-		if (matchesKey(data, Key.down)) {
-			this.moveSelection(1);
-			return;
-		}
-		if (matchesKey(data, Key.tab)) {
-			this.noteIndex = this.selected;
-			return;
-		}
-		if (matchesKey(data, Key.enter)) {
-			this.choose(this.selected);
-			return;
-		}
-		if (matchesKey(data, Key.escape)) {
-			this.complete({ decision: "deny" });
-			return;
-		}
-
-		const picked = CHOICES.findIndex((option) => option.key === data);
-		if (picked >= 0) this.selected = picked;
-	}
-
-	private moveSelection(delta: number): void {
-		const count = CHOICES.length;
-		this.selected = (this.selected + delta + count) % count;
-	}
-
-	private moveNote(delta: number): void {
-		if (this.noteIndex === null) return;
-		this.moveSelection(delta);
-		this.noteIndex = this.selected;
-	}
-
-	private choose(index: number): void {
-		const option = CHOICES[index];
-		if (!option) return;
-		this.selected = index;
-
-		if (option.always) {
-			this.pending = option;
-			this.pendingNote = this.draftNote();
-			this.noteIndex = null;
-			this.levelIndex = this.target.levels.length - 1;
-			this.scopeIndex = 0;
-			this.phase = "levels";
-			return;
-		}
-
-		this.complete({
-			decision: option.decision,
-			note: this.draftNote(),
-			remember: option.always ? this.target.levels[0] : undefined,
-		});
-	}
-
-	private confirmLevel(): void {
-		const level = this.target.levels[this.levelIndex];
-		if (!this.pending || level === undefined) return;
-
-		this.complete({
-			decision: this.pending.decision,
-			note: this.pendingNote,
-			remember: level,
-			scope: this.currentScope,
-		});
-	}
-
-	private get currentScope(): Scope {
-		return SCOPES[this.scopeIndex] ?? "session";
-	}
-
-	private draftNote(): string | undefined {
-		const input = this.activeNoteInput;
-		if (!input) return undefined;
-
-		const note = expandPastes(input.getValue(), this.pastes).trim();
-		return note || undefined;
-	}
-
-	private handleNoteInput(data: string): void {
-		if (this.pasteBuffer !== "" || data.includes(PASTE_START)) {
-			this.bufferPaste(data);
-			return;
-		}
-
-		if (this.keybindings.matches(data, "app.clipboard.pasteImage")) {
-			this.pasteClipboard();
-			return;
-		}
-
-		this.activeNoteInput?.handleInput(data);
-	}
-
-	private bufferPaste(data: string): void {
-		const start = data.indexOf(PASTE_START);
-		const text = this.pasteBuffer + (start === -1 ? data : data.slice(start + PASTE_START.length));
-		const end = text.indexOf(PASTE_END);
-
-		if (end === -1) {
-			this.pasteBuffer = text;
-			return;
-		}
-
-		this.pasteBuffer = "";
-		const index = this.noteIndex;
-		if (index !== null) this.insertPaste(index, text.slice(0, end));
-
-		const rest = text.slice(end + PASTE_END.length);
-		if (rest) this.handleNoteInput(rest);
-	}
-
-	private pasteClipboard(): void {
-		const index = this.noteIndex;
-		if (index === null) return;
-
-		void readClipboard().then((text) => {
-			if (!text) return;
-			this.insertPaste(index, text);
-			this.requestRender();
-		});
-	}
-
-	private insertPaste(index: number, pastedText: string): void {
-		const input = this.noteInputs[index];
-		if (!input) return;
-
-		const text = cleanPaste(pastedText);
-		if (shouldCollapse(text)) {
-			this.pasteId++;
-			this.pastes.set(this.pasteId, text);
-			input.handleInput(pasteMarker(this.pasteId, text));
-			return;
-		}
-
-		const spacer = /^[/~.]/.test(text) && /\w$/.test(input.getValue()) ? " " : "";
-		input.handleInput(spacer + text);
-	}
-
-	private levelLines(): string[] {
-		const lines = [this.theme.fg("muted", "always yes for...")];
-
-		for (const [index, level] of this.target.levels.entries()) {
-			const active = index === this.levelIndex;
-			const marker = active ? this.theme.fg("accent", "\u276f ") : "  ";
-			lines.push(marker + this.theme.fg(active ? "accent" : "text", level));
-		}
-
-		if (this.pendingNote) lines.push(this.theme.fg("muted", `note: ${this.pendingNote}`));
-		lines.push("");
-		lines.push(
-			this.theme.fg("muted", "scope: ") +
-				this.theme.fg("accent", SCOPE_LABEL[this.currentScope]) +
-				this.theme.fg("dim", "   (tab to change)"),
-		);
-		lines.push("");
-		lines.push(this.theme.fg("dim", "\u2191\u2193 depth   tab scope   enter confirm   esc back"));
-		return lines;
-	}
-
-	private renderOption(option: Choice, index: number, inner: number): string {
-		const active = index === this.selected;
-		const editing = this.noteIndex === index;
-		const input = this.noteInputs[index];
-		const draft = input?.getValue().trim() ?? "";
-		const marker = active ? this.theme.fg("accent", "\u276f ") : "  ";
-		const key = this.theme.fg(active ? "accent" : "dim", option.key);
-		const prefix = `${marker}${key}  `;
-
-		if (!editing && !draft) {
-			return `${prefix}${this.theme.fg(active ? option.tone : "text", option.label)}`;
-		}
-
-		const room = Math.max(1, inner - visibleWidth(prefix));
-		const label = truncateToWidth(`${option.label}, `, room);
-		const noteRoom = Math.max(1, room - visibleWidth(label));
-		const note = editing
-			? (input?.render(noteRoom)[0] ?? "")
-			: this.theme.fg("dim", truncateToWidth(draft, noteRoom));
-		const head = this.theme.fg(active ? option.tone : "text", label);
-		return truncateToWidth(`${prefix}${head}${note}`, inner);
-	}
-
-	private diffLines(): string[] {
-		if (!this.diff) return [];
-
-		const lines = renderDiff(this.diff).split("\n");
-		const shown = lines.slice(0, DIFF_ROWS);
-		const hidden = lines.length - shown.length;
-		if (hidden > 0) shown.push(this.theme.fg("dim", `\u2026 ${hidden} more lines`));
-		return ["", ...shown];
-	}
-
-	private summaryLines(inner: number): string[] {
-		const wrapped = wrapTextWithAnsi(this.target.summary || "(no input)", inner);
-		const shown = wrapped.slice(0, SUMMARY_ROWS);
-		const elideLast = wrapped.length > shown.length;
-
-		return shown.map((line, index) => {
-			const text =
-				elideLast && index === shown.length - 1
-					? `${truncateToWidth(line, Math.max(0, inner - 3))}...`
-					: line;
-			return this.theme.fg("muted", text);
-		});
-	}
-
-	private frame(lines: string[], width: number, inner: number, title: string): string[] {
-		const out: string[] = [this.topBorder(width, title)];
-
-		for (const line of lines) {
-			const clipped = truncateToWidth(line, inner);
-			const pad = " ".repeat(Math.max(0, inner - visibleWidth(clipped)));
-			out.push(
-				`${this.theme.fg("border", "\u2502")} ${clipped}${pad} ${this.theme.fg("border", "\u2502")}`,
-			);
-		}
-
-		out.push(this.theme.fg("border", `\u2570${"\u2500".repeat(Math.max(0, width - 2))}\u256f`));
-		return out;
-	}
-
-	private topBorder(width: number, title: string): string {
-		const room = Math.max(0, width - TITLE_CHROME_WIDTH);
-		const label = this.theme.fg("accent", truncateToWidth(title, Math.max(0, room - 3), "..."));
-		const dashes = Math.max(0, room - visibleWidth(label));
-
-		return (
-			this.theme.fg("border", TITLE_PREFIX) +
-			label +
-			this.theme.fg("border", ` ${"\u2500".repeat(dashes)}${TITLE_SUFFIX}`)
-		);
-	}
-}

package/src/ui/paste.ts

@@ -1,27 +0,0 @@
-export const PASTE_START = "\x1b[200~";
-export const PASTE_END = "\x1b[201~";
-
-const MARKER = /\[paste #(\d+)(?:\s[^\]]*)?\]/g;
-const MAX_CHARS = 1000;
-
-export function cleanPaste(text: string): string {
-	return text
-		.replace(/\r\n?/g, "\n")
-		.replace(/\t/g, "    ")
-		.split("")
-		.filter((char) => char === "\n" || char.charCodeAt(0) >= 32)
-		.join("");
-}
-
-export function shouldCollapse(text: string): boolean {
-	return text.includes("\n") || text.length > MAX_CHARS;
-}
-
-export function pasteMarker(id: number, text: string): string {
-	const lines = text.split("\n").length;
-	return lines > 1 ? `[paste #${id} +${lines} lines]` : `[paste #${id} ${text.length} chars]`;
-}
-
-export function expandPastes(text: string, pastes: Map<number, string>): string {
-	return text.replace(MARKER, (match, id: string) => pastes.get(Number(id)) ?? match);
-}