@tikoci/centrs 0.1.9-next.23 → 0.1.9-next.27

package/src/explain/pasted-prompt.ts

@@ -0,0 +1,198 @@
+import { buildTip, type Tip } from "../core/envelope.ts";
+import { type Segment, segmentStatements } from "./segment.ts";
+
+/**
+ * Pasted console-prompt repair (#370).
+ *
+ * Recognizes two grounded prompt shapes at the start of a *statement* (not a
+ * raw line, so prompt-looking text inside strings and comments stays legal):
+ *
+ * - `[user@host] <menu>> <command>` — e.g. `[admin@MikroTik] > /ip/address print`
+ *   at the root, or `[admin@MikroTik] /ip/address> add …` inside a menu, the
+ *   shape the manual's Console page shows; a HotLock prompt doubles the `>`
+ * - `/menu/path> <command>` — e.g. `/interface/lte> monitor lte1`
+ *
+ * Segmentation already split the document on real statement boundaries with
+ * string/comment awareness, so testing each segment's start is a lexical
+ * position, not a line-start regex. A prompt-looking line inside a multiline
+ * string is interior to its segment and never at a segment start; comment
+ * lines never become segments at all.
+ *
+ * Severity / envelope behavior (chosen, documented here per #370 scope):
+ * the tip is ADVISORY only and never changes `data.verdict`. The bracket
+ * shape already fails via `invalid-at-sign` (the `@` is a hard fault); the
+ * menu shape stays `warn` (abstention — offline cannot prove the menu
+ * exists on any given device). Output banners (`Flags:`, `Columns:`) and
+ * bare `>` forms are deliberately NOT detected here; they are separately
+ * grounded cases, not automatic extensions.
+ *
+ * The stripped candidate is offered as repair TEXT only and is never adopted
+ * or executed: tips carry no execution semantics. For the menu shape the
+ * candidate is the literal text after `>` (it runs in that menu's context
+ * on the device, not from the root).
+ *
+ * The candidate is the prompt-stripped tail of the ORIGINAL input — separators,
+ * blocks and newlines preserved verbatim — bounded by the next pasted prompt
+ * or the end of input, so each prompt in a transcript gets its own repair.
+ * Reconstructing from segment texts would flatten `{ ... }` blocks and drop
+ * whatever follows them. The slice needs analyzed-byte offsets as JS indices,
+ * which hold only when the segmentation reports `ascii`; otherwise the
+ * per-segment candidate stands (narrow, never wrong).
+ *
+ * No two adjacent quantifiers in BRACKET_PROMPT_RE can match the same bytes
+ * (the user part stops at the first `@`; the menu's leading space lives inside
+ * its optional group), so a near-miss fails in linear time.
+ */
+const BRACKET_PROMPT_RE =
+	/^\[[^[\]\r\n@]*@[^[\]\r\n]*\](?:\s*(\/[A-Za-z0-9_\-/]*))?\s*>>?\s*([\s\S]*)$/;
+const MENU_PROMPT_RE = /^(\/[A-Za-z0-9_\-/]+)\s*>>?\s*([\s\S]*)$/;
+
+export interface PastedPromptHit {
+	shape: "bracket" | "menu";
+	menu?: string;
+	candidate: string;
+}
+
+interface StrippedPrompt {
+	shape: "bracket" | "menu";
+	menu?: string;
+	/** Length of the prompt prefix within the segment text. */
+	promptEnd: number;
+	candidate: string;
+}
+
+/** True when re-segmenting `text` reports an unbalanced delimiter. */
+function hasUnbalancedDelimiters(text: string): boolean {
+	try {
+		return segmentStatements(text).defects.some(
+			(d) => d.code === "unbalanced-close" || d.code === "unclosed",
+		);
+	} catch {
+		return true;
+	}
+}
+
+export function detectPastedPrompts(input: string): PastedPromptHit[] {
+	const hits: PastedPromptHit[] = [];
+	let segments: Segment[];
+	let ascii: boolean;
+	try {
+		const result = segmentStatements(input);
+		segments = result.segments;
+		ascii = result.ascii;
+	} catch {
+		return hits;
+	}
+	// Per-segment prompt match. A bare prompt with no command ("prompt-empty")
+	// earns no hit but still bounds the previous hit's region.
+	const stripped: (StrippedPrompt | "prompt-empty" | null)[] = segments.map(
+		(segment) => {
+			const text = segment.text;
+			if (text.length === 0) return null;
+			const bracket = BRACKET_PROMPT_RE.exec(text);
+			if (bracket !== null) {
+				const menu = bracket[1];
+				const group = bracket[2] ?? "";
+				return group.trim().length > 0
+					? {
+							shape: "bracket",
+							...(menu && menu !== "/" ? { menu } : {}),
+							promptEnd: text.length - group.length,
+							candidate: group.trim(),
+						}
+					: "prompt-empty";
+			}
+			const menu = MENU_PROMPT_RE.exec(text);
+			if (menu !== null) {
+				const group = menu[2] ?? "";
+				return group.trim().length > 0
+					? {
+							shape: "menu",
+							menu: menu[1],
+							promptEnd: text.length - group.length,
+							candidate: group.trim(),
+						}
+					: "prompt-empty";
+			}
+			return null;
+		},
+	);
+	for (let i = 0; i < segments.length; i++) {
+		const hit = stripped[i];
+		if (hit === null || hit === undefined || hit === "prompt-empty") continue;
+		let candidate = hit.candidate;
+		if (ascii) {
+			const segment = segments[i];
+			let end = input.length;
+			for (let j = i + 1; j < segments.length; j++) {
+				if (stripped[j] !== null && stripped[j] !== undefined) {
+					end = segments[j]?.start ?? end;
+					break;
+				}
+			}
+			const sliced = input
+				.slice((segment?.start ?? 0) + hit.promptEnd, end)
+				.trim();
+			// The slice must not cross the prompt's enclosing container: it is
+			// kept only when it re-segments balanced, else the narrow
+			// per-segment candidate stands (`{ /menu> cmd }` would otherwise
+			// offer `cmd }`).
+			if (sliced.length > 0 && !hasUnbalancedDelimiters(sliced))
+				candidate = sliced;
+		}
+		hits.push({
+			shape: hit.shape,
+			...(hit.menu ? { menu: hit.menu } : {}),
+			candidate,
+		});
+	}
+	return hits;
+}
+
+/**
+ * A markdown code span that survives backticks in `text`: the fence is one
+ * longer than the longest backtick run inside, padded when `text` starts or
+ * ends with one (CommonMark code spans).
+ */
+function codeSpan(text: string): string {
+	const fence = "`".repeat(longestBacktickRun(text) + 1);
+	const pad = text.startsWith("`") || text.endsWith("`") ? " " : "";
+	return `${fence}${pad}${text}${pad}${fence}`;
+}
+
+/**
+ * A fenced code block for multi-line text: a code span would render its
+ * newlines as spaces, and `:put 1` NEWLINE `:put 2` is not `:put 1 :put 2`.
+ */
+function codeBlock(text: string): string {
+	const fence = "`".repeat(Math.max(3, longestBacktickRun(text) + 1));
+	return `${fence}\n${text}\n${fence}`;
+}
+
+function longestBacktickRun(text: string): number {
+	let longest = 0;
+	for (const run of text.match(/`+/g) ?? [])
+		longest = Math.max(longest, run.length);
+	return longest;
+}
+
+export function pastedPromptTips(input: string): Tip[] {
+	return detectPastedPrompts(input).map((hit) => {
+		const where = hit.menu ? ` (typed at ${codeSpan(hit.menu)})` : "";
+		const fix = /[\r\n]/.test(hit.candidate)
+			? `Drop the pasted prompt and try this${where} instead — this input was not executed:\n\n${codeBlock(hit.candidate)}`
+			: `Drop the pasted prompt and try ${codeSpan(hit.candidate)}${where} instead — this input was not executed.`;
+		if (hit.shape === "menu")
+			return buildTip(
+				"tip/explain-pasted-prompt",
+				`This looks like a pasted ${codeSpan(hit.menu ?? "")} menu prompt, not a command to run from the root.`,
+				fix,
+			);
+		const prompt = hit.menu ? `[user@host] ${hit.menu}>` : "[user@host] >";
+		return buildTip(
+			"tip/explain-pasted-prompt",
+			`This looks like a pasted console transcript (${codeSpan(prompt)}), not a command to run.`,
+			fix,
+		);
+	});
+}

package/src/explain/pathresolve.ts

@@ -1,8 +1,8 @@
 /**
  * Offline path resolution for `explain` (centrs canonicalizer).
  *
- * Ratified by the phase-0 lab, questions Q3 and Q4 (#185), promoted from the
- * throwaway probe `.scratch/explain-lab-pathresolve.ts`. Two surfaces:
+ * Ratified by the phase-0 lab, questions Q3 and Q4 (#185); the lab probe
+ * it was promoted from is history (see #185), not a runnable method. Two surfaces:
  *
  *   resolveStatements  (Q4) — the fully-qualified canonical path of every
  *                       statement in source order, tracking the persistent menu

package/src/explain/scope-brace.ts

@@ -7,8 +7,11 @@
  * gives comment masking, segmentation, and symbol resolution one rule.
  */
 
+import { commandVerbIndex } from "./catalog.ts";
+import { isKnownMenuPath } from "./is-known-menu.ts";
 import { scanQuotedString } from "./quoted-string.ts";
-import { runNamesCommand } from "./run-tokens.ts";
+import { runNamesCommand, runTokens } from "./run-tokens.ts";
+import { VERBS } from "./verbs.ts";
 
 /** Error-variable shape for `:onerror V { … }` — a bare/`$`-prefixed name. */
 const ERROR_VAR = /^\$?[A-Za-z][A-Za-z0-9._-]*$/;
@@ -96,17 +99,82 @@ const SCRIPT_BODY_ARG = /^(?:source|script|.+-script|on-.+)$/;
  * offline misses it.
  *
  * Abbreviating the FIRST segment (`down={ :beep }` for `down-script`, also
- * accepted on device) stays outside. Every word is a prefix of `<word>-script`,
- * so admitting it would admit `comment={ :beep }`. Telling them apart needs the
- * command's argument list, which is schema.
+ * accepted on device) stays outside the PROVEN shape. Every word is a prefix
+ * of `<word>-script`, so admitting it here would admit `comment={ :beep }` as
+ * a confident body. Telling them apart needs the command's argument list,
+ * which is schema — so a `name={` with a script-like body that reaches this
+ * far reads as a body for every reader (comments inside are comments) but is
+ * warned as a possible abbreviation instead of passing silently (#525,
+ * `args.ts` → `invalidCommandBraceOffsets`).
  */
 const SCRIPT_BODY_ABBREVIATION =
 	/^(?:s(?:o(?:u(?:r(?:c)?)?)?)?|sc(?:r(?:i(?:p)?)?)?|on?|.+-(?:s(?:c(?:r(?:i(?:p)?)?)?)?)?)$/;
 
-function isScriptBodyName(name: string): boolean {
+/** Whether `name` is a proven script-body slot (full or pinned abbreviation). */
+export function isScriptBodyName(name: string): boolean {
 	return SCRIPT_BODY_ARG.test(name) || SCRIPT_BODY_ABBREVIATION.test(name);
 }
 
+function isAsciiLetter(char: string | undefined): boolean {
+	if (char === undefined) return false;
+	return (char >= "A" && char <= "Z") || (char >= "a" && char <= "z");
+}
+
+/**
+ * Whether the `{` at `open` holds a script-like body (#525). `end` is the
+ * exclusive brace end (or the text length when unclosed).
+ *
+ * A body opens with a directive, an absolute command, or one bare command
+ * word: `{ :beep }`, `{ /ip … }`, `{ beep }` and `{ # comment⏎:beep }` are
+ * all accepted on CHR 7.25. A bare word followed by a top-level `;` is array
+ * members, not commands — `.proplist={name;comment}` is device-rejected —
+ * so it keeps the error, as do `{1;2}`, `{"x"}`, `{}` and `$`-led values,
+ * which cannot open a command at all. The scan touches each byte between
+ * the braces once, skipping strings and `#`-to-end-of-line runs, so it is
+ * linear; it works on masked and unmasked text alike (a masked comment is
+ * already whitespace).
+ */
+export function braceBodyIsScriptLike(
+	text: string,
+	open: number,
+	end: number,
+): boolean {
+	let j = open + 1;
+	for (;;) {
+		if (j >= end) return false;
+		const c = text[j] as string;
+		if (c === " " || c === "\t" || c === "\r" || c === "\n") {
+			j++;
+			continue;
+		}
+		if (c === "#") {
+			while (j < end && text[j] !== "\n") j++;
+			continue;
+		}
+		if (c === ":" || c === "/") return true;
+		if (!isAsciiLetter(c)) return false;
+		break;
+	}
+	let depth = 0;
+	while (j < end) {
+		const c = text[j] as string;
+		if (c === '"') {
+			const scan = scanQuotedString(text, j);
+			j = Math.min(scan.end, end);
+			continue;
+		}
+		if (c === "#") {
+			while (j < end && text[j] !== "\n") j++;
+			continue;
+		}
+		if (c === "{" || c === "[" || c === "(") depth++;
+		else if ((c === "}" || c === "]" || c === ")") && depth > 0) depth--;
+		else if (c === ";" && depth === 0) return false;
+		j++;
+	}
+	return true;
+}
+
 /** Grounded scripting directives whose positional arity makes a later `#` fatal. */
 const DIRECTIVE_POSITIONAL_ARITY: Readonly<Record<string, number>> = {
 	local: 2,
@@ -121,6 +189,12 @@ interface StatementIndex {
 	boundaries: Int32Array;
 	firstContent: Int32Array;
 	lastForbidden: Int32Array;
+	/**
+	 * The innermost open delimiter at each nested `;`/newline boundary. Sparse,
+	 * because a per-offset array pushed a 540 KiB document past
+	 * `BOUNDARY_CACHE_BYTE_LIMIT` and made every probe rebuild the index.
+	 */
+	nestedSeparators: Map<number, number>;
 	matchingBrace: Map<number, number>;
 }
 
@@ -162,6 +236,7 @@ function boundaryCacheEntryBytes(text: string, index: StatementIndex): number {
 		index.boundaries.byteLength +
 		index.firstContent.byteLength +
 		index.lastForbidden.byteLength +
+		index.nestedSeparators.size * 32 +
 		index.matchingBrace.size * 32
 	);
 }
@@ -223,17 +298,34 @@ function statementIndex(text: string): StatementIndex {
 	firstContent.fill(-1);
 	const lastForbidden = new Int32Array(text.length + 1);
 	lastForbidden.fill(-1);
+	const nestedSeparators = new Map<number, number>();
 	const matchingBrace = new Map<number, number>();
 	const delimiters: { char: string; at: number }[] = [];
 	let boundary = -1;
 	let first = -1;
 	let forbidden = -1;
+	let comment = false;
 	let i = 0;
 	while (i < text.length) {
 		boundaries[i] = boundary;
 		firstContent[i] = first;
 		lastForbidden[i] = forbidden;
 		const c = text[i] as string;
+		// A statement-leading `#` runs to the line end, and a `{`, `}` or `"` in
+		// it is not structure: `/ip { # }⏎address { print {1;2} } }` is rejected
+		// at the inner `{` on CHR 7.24.5 and 7.23.8, so the `}` must not close
+		// `/ip {` (#351). Read raw, the bytes are blank, as `maskComments` makes
+		// them; read masked, they already are.
+		if (comment && c !== "\n") {
+			i++;
+			continue;
+		}
+		comment = false;
+		if (c === "#" && first === -1 && delimiters.at(-1)?.char !== "(") {
+			comment = true;
+			i++;
+			continue;
+		}
 		if (c === '"') {
 			const end = Math.min(scanQuotedString(text, i).end, text.length);
 			boundaries.fill(boundary, i + 1, end + 1);
@@ -255,6 +347,9 @@ function statementIndex(text: string): StatementIndex {
 		if (first === -1 && !isAsciiWhitespace(c)) first = i;
 		if (c === "=" || c === "[" || c === "(" || c === "$") forbidden = i;
 		if (c === "\n" || c === ";" || c === "{" || c === "[") {
+			const open = delimiters.at(-1);
+			if ((c === "\n" || c === ";") && open !== undefined)
+				nestedSeparators.set(i, open.at);
 			boundary = i;
 			first = -1;
 		}
@@ -267,6 +362,7 @@ function statementIndex(text: string): StatementIndex {
 		boundaries,
 		firstContent,
 		lastForbidden,
+		nestedSeparators,
 		matchingBrace,
 	};
 	if (cacheStatementIndex(text, index)) adoptBoundaryText(text, index);
@@ -462,18 +558,41 @@ export function scopeNameFromMasked(
  * Whether this brace begins a context in which statement-leading comments exist.
  *
  * `floor` bounds the lookback exactly as in {@link scopeNameFromMasked}.
+ * `unprovenName` decides the unproven `name={` guess below: `"body"` reads it
+ * as a body, `"value"` as a value. Only the script-like disjunct is gated —
+ * a proven slot stays a body either way. Readers that are themselves deciding
+ * an error AT this brace pass `"value"` where the slot cannot bear a body
+ * (`args.ts` for a root directive's slots and a `where` named comparison,
+ * `group-faults.ts` for the bracketed form), so the guess does not swallow
+ * their error; every other reader keeps `"body"`.
  */
 export function braceStartsStatements(
 	text: string,
 	open: number,
 	floor = 0,
+	unprovenName: "body" | "value" = "body",
 ): boolean {
 	if (scopeNameFromMasked(text, open, floor) !== null) return true;
 	const index = statementIndex(text);
 	const boundary = index.boundaries[open] ?? -1;
 	const start = Math.max(boundary + 1, floor);
 	const named = trailingName(text, start, open);
-	if (named !== null) return isScriptBodyName(named.toLowerCase());
+	if (named !== null) {
+		// A `name={` with a script-like body reads as a body for every
+		// reader, proven slot or not (#525): `down={ beep }` and
+		// `down={ # comment⏎:beep }` are accepted on CHR 7.25, and the `#`
+		// is only a comment when the brace bears statements. The warning
+		// that marks the unproven slot lives in `args.ts`, which checks
+		// ambiguity before this skip.
+		if (isScriptBodyName(named.toLowerCase())) return true;
+		if (unprovenName === "value") return false;
+		const close = matchingBraceEnd(text, open);
+		return braceBodyIsScriptLike(
+			text,
+			open,
+			close === undefined ? text.length : close + 1,
+		);
+	}
 	// `source { :beep }` — the same body with the `=` left out (#350). Every
 	// grounded spelling lowers to the `source=` IL on CHR 7.22.1 and 7.24.5:
 	// `/system/script add name=beep source { :beep }`, `/system/scheduler add
@@ -493,12 +612,108 @@ export function braceStartsStatements(
 	// but a run that already names a command makes the brace its operand (#496).
 	// `start` follows the last `{`, so each brace reads its own run: linear.
 	const first = index.firstContent[open] ?? -1;
-	return (
-		first < start ||
-		(text[first] === "/" &&
+	if (first < start) return true;
+	if (text[first] === "/")
+		return (
 			(index.lastForbidden[open] ?? -1) < start &&
-			!runNamesCommand(text.slice(first, open)))
-	);
+			!runNamesCommand(text.slice(first, open))
+		);
+	return menuBlockPath(text, open, floor) !== null;
+}
+
+/** Nesting a {@link menuBlockPath} lookup follows before it abstains. */
+const MAX_MENU_BLOCK_DEPTH = 64;
+
+/**
+ * A relative run of bare path words, space- or slash-separated. Each word is
+ * `pathresolve`'s `BARE_WORD`: the resolver reads no digit-led word as a path,
+ * so admitting `6to4 {` here would flatten a block whose navigation it then
+ * ignores, resolving the body's `print` against `/interface`.
+ */
+const RELATIVE_MENU_RUN =
+	/^[A-Za-z][A-Za-z0-9._-]*(?:[ \t/]+[A-Za-z][A-Za-z0-9._-]*)*$/;
+
+/**
+ * The menu a `{` opens a statement block over, when the source alone says so
+ * (#351). Null means offline cannot tell, not that the brace is a value.
+ *
+ * On CHR 7.24.5 and 7.23.8 a brace right after a menu word is always a
+ * statement block, at any depth and whatever the body holds:
+ * `/ip { address { 1;2 } }` is `bad command name 1` at the `1`, and
+ * `/ip { address { a;b } }` reads `a` as `add`. A brace after a command word is
+ * always an error at the `{` (`/ip { address { print {1;2} } }`). The `/`-led
+ * spelling was already read as a block; the RELATIVE one (`address {` inside
+ * `/ip { … }`) was read as `/ip address` with a brace operand. That is what
+ * hard-failed the outer brace at depth three and hid every fault in the body.
+ *
+ * A relative run is a block only when the menu it names is known: the
+ * enclosing container's path, read the same way outward, plus the run, named by
+ * a shipped structure table. A miss abstains, so an unknown word keeps today's
+ * reading and the resolver says `unresolved`. The path is lexical: a
+ * navigation statement earlier in the same body (`/ip { firewall; address {`)
+ * is not followed, and the resolver checks the flattened run against the real
+ * context, so that residue can only abstain. Abbreviated menus (`addr {`) are
+ * not expanded, as R13 does not expand them.
+ *
+ * `floor` keeps the ranged-call contract of {@link scopeNameFromMasked}: no
+ * enclosing brace before it is consulted, so a range reads exactly as the same
+ * text taken alone.
+ */
+export function menuBlockPath(
+	text: string,
+	open: number,
+	floor = 0,
+): readonly string[] | null {
+	return blockPathAt(text, statementIndex(text), open, floor, 0);
+}
+
+function blockPathAt(
+	text: string,
+	index: StatementIndex,
+	open: number,
+	floor: number,
+	depth: number,
+): readonly string[] | null {
+	if (depth > MAX_MENU_BLOCK_DEPTH) return null;
+	const start = Math.max((index.boundaries[open] ?? -1) + 1, floor);
+	const first = index.firstContent[open] ?? -1;
+	if (first < start) return enclosingBlockPath(text, index, open, floor, depth);
+	if ((index.lastForbidden[open] ?? -1) >= start) return null;
+	const run = text.slice(first, open);
+	if (text[first] === "/") {
+		if (runNamesCommand(run)) return null;
+		return runTokens(run).map((token) => token.name);
+	}
+	const trimmed = run.trim();
+	if (!RELATIVE_MENU_RUN.test(trimmed)) return null;
+	const names = trimmed.split(/[\s/]+/);
+	if (names.some((name) => VERBS.has(name))) return null;
+	const parent = enclosingBlockPath(text, index, open, floor, depth);
+	if (parent === null) return null;
+	const path = [...parent, ...names];
+	if (commandVerbIndex(path) !== null || !isKnownMenuPath(path)) return null;
+	return path;
+}
+
+/**
+ * The path of the container `{` around the statement that holds `at`, when it
+ * is one. The statement starts after a boundary: an opening `{`/`[` is the
+ * enclosing delimiter itself, and a separator records it.
+ */
+function enclosingBlockPath(
+	text: string,
+	index: StatementIndex,
+	at: number,
+	floor: number,
+	depth: number,
+): readonly string[] | null {
+	const boundary = index.boundaries[at] ?? -1;
+	const outer =
+		boundary < 0 || text[boundary] === "{" || text[boundary] === "["
+			? boundary
+			: (index.nestedSeparators.get(boundary) ?? -1);
+	if (outer < floor || text[outer] !== "{") return null;
+	return blockPathAt(text, index, outer, floor, depth + 1);
 }
 
 /**