@oh-my-pi/pi-coding-agent 14.5.14 → 14.6.0

package/src/eval/parse.ts

@@ -1,6 +1,6 @@
 import type { EvalLanguage } from "./types";
 
-export type EvalLanguageOrigin = "default" | "fence";
+export type EvalLanguageOrigin = "default" | "header";
 
 export interface ParsedEvalCell {
 	index: number;
@@ -19,11 +19,11 @@ export interface ParsedEvalInput {
 const DEFAULT_TIMEOUT_MS = 30_000;
 
 /**
- * Canonical fenced-language tokens we map onto our two backends. Matched
- * case-insensitively. Anything else found in a fence info string is treated as
- * a title fragment rather than a language; this is intentional fallback
- * behaviour and MUST NOT be advertised in the tool's prompt — the lark grammar
- * describes the canonical surface we encourage callers to emit.
+ * Canonical language tokens we map onto our two backends. Matched
+ * case-insensitively. Unknown tokens are treated as title fragments rather
+ * than languages; this is intentional fallback behaviour and MUST NOT be
+ * advertised in the tool's prompt — the lark grammar describes the
+ * canonical surface we encourage callers to emit.
  */
 const LANGUAGE_ALIASES: Record<string, EvalLanguage> = {
 	py: "python",
@@ -41,8 +41,8 @@ function resolveLanguageAlias(token: string): EvalLanguage | undefined {
 }
 
 /**
- * Map an attribute key (from `key=value` in a fence info string) to one of
- * the three canonical roles. Canonical keys: `id`, `t`, `rst`. Fallback
+ * Map an attribute key (from `key:value` or bare `key` in a header) to one
+ * of the three canonical roles. Canonical keys: `id`, `t`, `rst`. Fallback
  * aliases — accepted but not advertised in the prompt — cover common
  * synonyms the LLM is likely to reach for instead of the short canonical.
  */
@@ -57,29 +57,22 @@ function classifyAttrKey(key: string): "id" | "t" | "rst" | null {
 	return null;
 }
 
-interface RawBlock {
-	type: "raw";
-	lines: string[];
-	startLine: number;
-}
-
-interface FencedBlock {
-	type: "fenced";
-	info: string;
-	codeLines: string[];
-	startLine: number;
-}
-
-type Block = RawBlock | FencedBlock;
-
-interface FenceInfo {
+interface HeaderInfo {
 	language?: EvalLanguage;
 	title?: string;
 	timeoutMs?: number;
 	reset?: boolean;
 }
 
-const ATTR_TOKEN_RE = /^([a-zA-Z][\w-]*)=(?:"([^"]*)"|'([^']*)'|(.*))$/;
+/**
+ * Match a header line: `={5,} <info>? ={5,}`. Both bars MUST be on the
+ * same line and each MUST be at least five equal signs (lengths need not
+ * match — a 5/6 split is fine).
+ */
+const HEADER_RE = /^={5,}([^=].*?)?={5,}\s*$/;
+const EMPTY_HEADER_RE = /^={5,}\s*$/;
+
+const ATTR_TOKEN_RE = /^([a-zA-Z][\w-]*)(?::(?:"([^"]*)"|'([^']*)'|(.*)))?$/;
 const DURATION_TOKEN_RE = /^\d+(?:ms|s|m)?$/;
 
 function parseDurationMs(raw: string, lineNumber: number): number {
@@ -111,24 +104,26 @@ function trimOuterBlankLines(lines: string[]): string[] {
 	return lines.slice(start, end);
 }
 
-function parseFenceOpener(line: string): { char: "`" | "~"; count: number; info: string } | null {
-	const opener = /^(`{3,}|~{3,})(.*)$/.exec(line);
-	if (!opener) return null;
-	const run = opener[1];
-	return { char: run[0] as "`" | "~", count: run.length, info: opener[2].trim() };
-}
-
-function isFenceCloser(line: string, char: "`" | "~", minCount: number): boolean {
-	let count = 0;
-	while (count < line.length && line[count] === char) count++;
-	if (count < minCount) return false;
-	return line.slice(count).trim() === "";
+/**
+ * Detect whether a line is a cell header. Returns the info string between
+ * the two bar runs (trimmed) when it is, or `null` otherwise. An empty
+ * header (`===== =====` or just `=====`) yields an empty info string.
+ *
+ * A line that contains text but only one bar (e.g. `===== title`) is NOT
+ * a header — it's normal code that happens to start with equal signs.
+ */
+function parseHeaderLine(line: string): string | null {
+	if (EMPTY_HEADER_RE.test(line)) return "";
+	const match = HEADER_RE.exec(line);
+	if (!match) return null;
+	return (match[1] ?? "").trim();
 }
 
 /**
- * Tokenize a fence info string while preserving content inside matching
- * single or double quotes as a single token. The opening and closing quote
- * characters are kept verbatim so attribute parsing can strip them later.
+ * Tokenize a header info string while preserving content inside matching
+ * single or double quotes as a single token. The opening and closing
+ * quote characters are kept verbatim so attribute parsing can strip them
+ * later.
  */
 function tokenizeInfoString(info: string): string[] {
 	const tokens: string[] = [];
@@ -161,71 +156,83 @@ function tokenizeInfoString(info: string): string[] {
 }
 
 /**
- * Decode a fence info string into language, title, timeout, and reset flag.
- *
- * Layout (positional → kv, all optional):
- *   `<lang>? <duration>? <(title-fragment | key=value)>*`
+ * Decode a header info string into language, title, timeout, and reset flag.
  *
- * Canonical attribute keys (the only ones surfaced in the lark grammar):
- *   - `id`  → cell title
- *   - `t`   → per-cell timeout
- *   - `rst` → boolean reset for this cell's kernel
+ * Token forms (all optional, any order):
+ *   - `py` / `js` / `ts`              bare language
+ *   - `py:"..."` / `js:"..."` / `ts:"..."`  language + title shorthand
+ *   - `id:"..."`                      cell title
+ *   - `t:<duration>`                  per-cell timeout
+ *   - `<duration>`                    bare positional duration (lenient)
+ *   - `rst`                           reset flag
+ *   - `rst:true|false`                reset flag with explicit value
  *
- * Lenient fallback aliases (NOT advertised in the prompt; we silently accept
- * them when the LLM reaches for a more familiar key):
+ * Fallback aliases (accepted but not advertised in the prompt):
  *   - id:  title, name, cell, file, label
  *   - t:   timeout, duration, time
  *   - rst: reset
  *
- * Truly unknown keys are silently dropped. First occurrence wins when a key
- * is repeated (canonical or alias).
- *
- * - First token is consumed as a language alias when it matches one; otherwise
- *   it falls through to the title-fragment branch and the cell inherits the
- *   surrounding language.
- * - The first remaining duration-shaped token (e.g. `15s`, `500ms`, `2m`,
- *   `30`) becomes the positional timeout. The `t=` attribute always wins.
- * - Anything else accumulates as positional title fragments joined by spaces.
+ * Truly unknown keys are silently dropped. First occurrence wins when a
+ * key is repeated (canonical or alias). Anything that doesn't classify
+ * accumulates as a positional title fragment joined by spaces.
  */
-function parseFenceInfo(info: string, lineNumber: number): FenceInfo {
-	const tokens = tokenizeInfoString(info.trim());
+function parseHeaderInfo(info: string, lineNumber: number): HeaderInfo {
+	const tokens = tokenizeInfoString(info);
 	if (tokens.length === 0) return {};
 
 	let language: EvalLanguage | undefined;
+	let titleAttr: string | undefined;
 	let positionalDurationMs: number | undefined;
-	const titleParts: string[] = [];
-	let idAttr: string | undefined;
 	let tAttr: string | undefined;
 	let rstAttr: string | undefined;
+	let bareReset = false;
+	const titleParts: string[] = [];
+
+	for (const token of tokens) {
+		// Bare reset flag.
+		if (RST_KEYS.has(token.toLowerCase())) {
+			bareReset = true;
+			continue;
+		}
 
-	for (let idx = 0; idx < tokens.length; idx++) {
-		const token = tokens[idx];
 		const attrMatch = ATTR_TOKEN_RE.exec(token);
-		if (attrMatch) {
+		if (attrMatch && token.includes(":")) {
 			const key = attrMatch[1].toLowerCase();
 			const value = attrMatch[2] ?? attrMatch[3] ?? attrMatch[4] ?? "";
+
+			// Language-with-title shorthand: `py:"foo"` etc.
+			const langCandidate = resolveLanguageAlias(key);
+			if (langCandidate) {
+				if (language === undefined) language = langCandidate;
+				if (titleAttr === undefined && value !== "") titleAttr = value;
+				continue;
+			}
+
 			const role = classifyAttrKey(key);
-			if (role === "id" && idAttr === undefined) idAttr = value;
+			if (role === "id" && titleAttr === undefined) titleAttr = value;
 			else if (role === "t" && tAttr === undefined) tAttr = value;
 			else if (role === "rst" && rstAttr === undefined) rstAttr = value;
 			// unknown / repeated keys silently dropped
 			continue;
 		}
-		if (idx === 0) {
-			const lang = resolveLanguageAlias(token);
-			if (lang) {
-				language = lang;
-				continue;
-			}
+
+		// Bare language token (no colon).
+		const lang = resolveLanguageAlias(token);
+		if (lang && language === undefined) {
+			language = lang;
+			continue;
 		}
+
+		// Bare positional duration (lenient — `t:` is canonical).
 		if (positionalDurationMs === undefined && DURATION_TOKEN_RE.test(token)) {
 			positionalDurationMs = parseDurationMs(token, lineNumber);
 			continue;
 		}
+
 		titleParts.push(token);
 	}
 
-	const explicitTitle = (idAttr ?? "").trim();
+	const explicitTitle = (titleAttr ?? "").trim();
 	const positionalTitle = titleParts.join(" ").trim();
 	const title = explicitTitle.length > 0 ? explicitTitle : positionalTitle.length > 0 ? positionalTitle : undefined;
 
@@ -243,55 +250,13 @@ function parseFenceInfo(info: string, lineNumber: number): FenceInfo {
 			throw new Error(`Eval line ${lineNumber}: invalid rst value \`${rstAttr}\`; use true or false.`);
 		}
 		reset = parsed;
+	} else if (bareReset) {
+		reset = true;
 	}
 
 	return { language, title, timeoutMs, reset };
 }
 
-/**
- * Walk normalized lines and split into top-level fenced blocks and raw
- * (between/around fences) blocks. Unclosed fences are leniently closed at
- * end-of-input. Raw blocks with only blank lines are dropped.
- */
-function splitIntoBlocks(lines: string[]): Block[] {
-	const blocks: Block[] = [];
-	let i = 0;
-	while (i < lines.length) {
-		const line = lines[i];
-		const opener = parseFenceOpener(line);
-		if (opener) {
-			const fenceStart = i + 1; // 1-indexed line number of opener
-			const codeLines: string[] = [];
-			let j = i + 1;
-			let closed = false;
-			while (j < lines.length) {
-				if (isFenceCloser(lines[j], opener.char, opener.count)) {
-					closed = true;
-					break;
-				}
-				codeLines.push(lines[j]);
-				j++;
-			}
-			blocks.push({ type: "fenced", info: opener.info, codeLines, startLine: fenceStart });
-			i = closed ? j + 1 : j;
-		} else {
-			const rawStart = i + 1;
-			const rawLines: string[] = [line];
-			let j = i + 1;
-			while (j < lines.length && !parseFenceOpener(lines[j])) {
-				rawLines.push(lines[j]);
-				j++;
-			}
-			const trimmed = trimOuterBlankLines(rawLines);
-			if (trimmed.length > 0) {
-				blocks.push({ type: "raw", lines: trimmed, startLine: rawStart });
-			}
-			i = j;
-		}
-	}
-	return blocks;
-}
-
 interface ExpansionState {
 	language: EvalLanguage;
 	languageOrigin: EvalLanguageOrigin;
@@ -300,34 +265,69 @@ interface ExpansionState {
 export function parseEvalInput(input: string): ParsedEvalInput {
 	const normalized = input.replace(/\r\n?/g, "\n");
 	const lines = normalized.split("\n");
-	const blocks = splitIntoBlocks(lines);
+	// `split("\n")` produces a trailing empty element when the input ends with
+	// a newline. Drop it so we don't emit phantom blank trailing code lines.
+	if (lines.length > 0 && lines[lines.length - 1] === "") lines.pop();
 
 	const state: ExpansionState = { language: "python", languageOrigin: "default" };
 	const cells: ParsedEvalCell[] = [];
-	for (const block of blocks) {
-		if (block.type === "raw") {
+	let i = 0;
+
+	// Lenient: leading content before any header forms an implicit
+	// default-language cell. Drop it if it's only blank lines.
+	if (i < lines.length && parseHeaderLine(lines[i]) === null) {
+		const buffer: string[] = [];
+		while (i < lines.length && parseHeaderLine(lines[i]) === null) {
+			buffer.push(lines[i]);
+			i++;
+		}
+		const trimmed = trimOuterBlankLines(buffer);
+		if (trimmed.length > 0) {
 			cells.push({
 				index: cells.length,
 				title: undefined,
-				code: block.lines.join("\n"),
+				code: trimmed.join("\n"),
 				language: state.language,
 				languageOrigin: state.languageOrigin,
 				timeoutMs: DEFAULT_TIMEOUT_MS,
 				reset: false,
 			});
+		}
+	}
+
+	while (i < lines.length) {
+		const headerInfo = parseHeaderLine(lines[i]);
+		if (headerInfo === null) {
+			// Loop invariant guarantees this is a header line; guard anyway.
+			i++;
 			continue;
 		}
-		const fence = parseFenceInfo(block.info, block.startLine);
-		const language = fence.language ?? state.language;
-		const languageOrigin: EvalLanguageOrigin = fence.language ? "fence" : state.languageOrigin;
+		const headerLineNumber = i + 1;
+		const info = parseHeaderInfo(headerInfo, headerLineNumber);
+		i++; // consume header line
+
+		const codeLines: string[] = [];
+		while (i < lines.length && parseHeaderLine(lines[i]) === null) {
+			codeLines.push(lines[i]);
+			i++;
+		}
+		// Strip trailing blank lines so visual spacing between cells doesn't
+		// leak into the preceding cell's code.
+		while (codeLines.length > 0 && codeLines[codeLines.length - 1].trim() === "") {
+			codeLines.pop();
+		}
+
+		const language = info.language ?? state.language;
+		const languageOrigin: EvalLanguageOrigin = info.language ? "header" : state.languageOrigin;
+
 		cells.push({
 			index: cells.length,
-			title: fence.title,
-			code: block.codeLines.join("\n"),
+			title: info.title,
+			code: codeLines.join("\n"),
 			language,
 			languageOrigin,
-			timeoutMs: fence.timeoutMs ?? DEFAULT_TIMEOUT_MS,
-			reset: fence.reset ?? false,
+			timeoutMs: info.timeoutMs ?? DEFAULT_TIMEOUT_MS,
+			reset: info.reset ?? false,
 		});
 		state.language = language;
 		state.languageOrigin = languageOrigin;

package/src/eval/py/prelude.py

@@ -3,8 +3,7 @@ from __future__ import annotations
 if "__omp_prelude_loaded__" not in globals():
     __omp_prelude_loaded__ = True
     from pathlib import Path
-    import os, re, json, shutil, subprocess
-    from datetime import datetime
+    import os, json, shutil, subprocess
     from IPython.display import display as _ipy_display, JSON
 
     _PRESENTABLE_REPRS = (
@@ -80,184 +79,6 @@ if "__omp_prelude_loaded__" not in globals():
             f.write(content)
         _emit_status("append", path=str(p), chars=len(content))
         return p
-    def _load_gitignore_patterns(base: Path) -> list[str]:
-        """Load .gitignore patterns from base directory and parents."""
-        patterns: list[str] = []
-        # Always exclude these
-        patterns.extend(["**/.git", "**/.git/**", "**/node_modules", "**/node_modules/**"])
-        # Walk up to find .gitignore files
-        current = base.resolve()
-        for _ in range(20):  # Limit depth
-            gitignore = current / ".gitignore"
-            if gitignore.exists():
-                try:
-                    for line in gitignore.read_text().splitlines():
-                        line = line.strip()
-                        if line and not line.startswith("#"):
-                            # Normalize pattern for fnmatch
-                            if line.startswith("/"):
-                                patterns.append(str(current / line[1:]))
-                            else:
-                                patterns.append(f"**/{line}")
-                except Exception:
-                    pass
-            parent = current.parent
-            if parent == current:
-                break
-            current = parent
-        return patterns
-
-    def _match_gitignore(path: Path, patterns: list[str], base: Path) -> bool:
-        """Check if path matches any gitignore pattern."""
-        import fnmatch
-        rel = str(path.relative_to(base)) if path.is_relative_to(base) else str(path)
-        abs_path = str(path.resolve())
-        for pat in patterns:
-            if pat.startswith("**/"):
-                # Match against any part of the path
-                if fnmatch.fnmatch(rel, pat) or fnmatch.fnmatch(rel, pat[3:]):
-                    return True
-                # Also check each path component
-                for part in path.parts:
-                    if fnmatch.fnmatch(part, pat[3:]):
-                        return True
-            elif fnmatch.fnmatch(abs_path, pat) or fnmatch.fnmatch(rel, pat):
-                return True
-        return False
-
-    def find(
-        pattern: str,
-        path: str | Path = ".",
-        *,
-        type: str = "file",
-        limit: int = 1000,
-        hidden: bool = False,
-        sort_by_mtime: bool = False,
-        maxdepth: int | None = None,
-        mindepth: int | None = None,
-    ) -> list[Path]:
-        """Recursive glob find. Respects .gitignore.
-        
-        maxdepth/mindepth are relative to path (0 = path itself, 1 = direct children).
-        """
-        p = Path(path).resolve()
-        base_depth = len(p.parts)
-        ignore_patterns = _load_gitignore_patterns(p)
-        matches: list[Path] = []
-        for m in p.rglob(pattern):
-            if len(matches) >= limit:
-                break
-            # Check depth constraints
-            rel_depth = len(m.resolve().parts) - base_depth
-            if maxdepth is not None and rel_depth > maxdepth:
-                continue
-            if mindepth is not None and rel_depth < mindepth:
-                continue
-            # Skip hidden files unless requested
-            if not hidden and any(part.startswith(".") for part in m.parts):
-                continue
-            # Skip gitignored paths
-            if _match_gitignore(m, ignore_patterns, p):
-                continue
-            # Filter by type
-            if type == "file" and m.is_dir():
-                continue
-            if type == "dir" and not m.is_dir():
-                continue
-            matches.append(m)
-        if sort_by_mtime:
-            matches.sort(key=lambda x: x.stat().st_mtime, reverse=True)
-        else:
-            matches.sort()
-        _emit_status("find", pattern=pattern, path=str(p), count=len(matches), matches=[str(m) for m in matches[:20]])
-        return matches
-
-    def grep(
-        pattern: str,
-        path: str | Path,
-        *,
-        ignore_case: bool = False,
-        literal: bool = False,
-        context: int = 0,
-    ) -> list[dict]:
-        """Grep a single file. Returns dicts with line/text fields."""
-        p = Path(path)
-        lines = p.read_text(encoding="utf-8").splitlines()
-        if literal:
-            if ignore_case:
-                match_fn = lambda line: pattern.lower() in line.lower()
-            else:
-                match_fn = lambda line: pattern in line
-        else:
-            flags = re.IGNORECASE if ignore_case else 0
-            rx = re.compile(pattern, flags)
-            match_fn = lambda line: rx.search(line) is not None
-        
-        match_lines: set[int] = set()
-        for i, line in enumerate(lines, 1):
-            if match_fn(line):
-                match_lines.add(i)
-        
-        # Expand with context
-        if context > 0:
-            expanded: set[int] = set()
-            for ln in match_lines:
-                for offset in range(-context, context + 1):
-                    expanded.add(ln + offset)
-            output_lines = sorted(ln for ln in expanded if 1 <= ln <= len(lines))
-        else:
-            output_lines = sorted(match_lines)
-        
-        hits = [{"line": ln, "text": lines[ln - 1]} for ln in output_lines]
-        _emit_status("grep", pattern=pattern, path=str(p), count=len(match_lines), hits=hits[:10])
-        return hits
-
-    def rgrep(
-        pattern: str,
-        path: str | Path = ".",
-        *,
-        glob_pattern: str = "*",
-        ignore_case: bool = False,
-        literal: bool = False,
-        limit: int = 100,
-        hidden: bool = False,
-    ) -> list[dict]:
-        """Recursive grep across files matching glob_pattern. Returns dicts with file/line/text fields. Respects .gitignore."""
-        if literal:
-            if ignore_case:
-                match_fn = lambda line: pattern.lower() in line.lower()
-            else:
-                match_fn = lambda line: pattern in line
-        else:
-            flags = re.IGNORECASE if ignore_case else 0
-            rx = re.compile(pattern, flags)
-            match_fn = lambda line: rx.search(line) is not None
-        
-        base = Path(path)
-        ignore_patterns = _load_gitignore_patterns(base)
-        hits: list[dict] = []
-        for file_path in base.rglob(glob_pattern):
-            if len(hits) >= limit:
-                break
-            if file_path.is_dir():
-                continue
-            # Skip hidden files unless requested
-            if not hidden and any(part.startswith(".") for part in file_path.parts):
-                continue
-            # Skip gitignored paths
-            if _match_gitignore(file_path, ignore_patterns, base):
-                continue
-            try:
-                lines = file_path.read_text(encoding="utf-8").splitlines()
-            except Exception:
-                continue
-            for i, line in enumerate(lines, 1):
-                if len(hits) >= limit:
-                    break
-                if match_fn(line):
-                    hits.append({"file": str(file_path), "line": i, "text": line})
-        _emit_status("rgrep", pattern=pattern, path=str(base), count=len(hits), hits=hits[:10])
-        return hits
     class ShellResult:
         """Result from shell command execution."""
         __slots__ = ("args", "stdout", "stderr", "returncode")
@@ -409,20 +230,6 @@ if "__omp_prelude_loaded__" not in globals():
         _emit_status("tree", path=str(base), entries=len(lines) - 1, preview=out[:1000])
         return out
 
-    def stat(path: str | Path) -> dict:
-        """Get file/directory info."""
-        p = Path(path)
-        s = p.stat()
-        info = {
-            "path": str(p),
-            "size": s.st_size,
-            "is_file": p.is_file(),
-            "is_dir": p.is_dir(),
-            "mtime": datetime.fromtimestamp(s.st_mtime).isoformat(),
-        }
-        _emit_status("stat", path=str(p), size=s.st_size, is_dir=p.is_dir(), mtime=info["mtime"])
-        return info
-
     def diff(a: str | Path, b: str | Path) -> str:
         """Compare two files, return unified diff."""
         import difflib
@@ -434,31 +241,6 @@ if "__omp_prelude_loaded__" not in globals():
         _emit_status("diff", file_a=str(path_a), file_b=str(path_b), identical=not out, preview=out[:500])
         return out
 
-    def glob(pattern: str, path: str | Path = ".", *, hidden: bool = False) -> list[str]:
-        """Non-recursive glob (use find() for recursive). Respects .gitignore."""
-        p = Path(path)
-        ignore_patterns = _load_gitignore_patterns(p)
-        matches: list[Path] = []
-        for m in p.glob(pattern):
-            # Skip hidden files unless requested
-            if not hidden and m.name.startswith("."):
-                continue
-            # Skip gitignored paths
-            if _match_gitignore(m, ignore_patterns, p):
-                continue
-            matches.append(m)
-        matches = sorted(matches)
-        _emit_status("glob", pattern=pattern, path=str(p), count=len(matches), matches=[str(m) for m in matches[:20]])
-        return matches
-
-    def sed(path: str | Path, pattern: str, repl: str, *, flags: int = 0) -> int:
-        """Regex replace in file (like sed -i). Returns count."""
-        p = Path(path)
-        data = p.read_text(encoding="utf-8")
-        new, count = re.subn(pattern, repl, data, flags=flags)
-        p.write_text(new, encoding="utf-8")
-        _emit_status("sed", path=str(p), count=count)
-        return count
     def output(
         *ids: str,
         format: str = "raw",