pi-repl-py 0.1.0 → 0.1.1

package/src/extension/preview/descriptor.ts

@@ -0,0 +1,28 @@
+// --- descriptor: collapse the raw line into one readable, safe, width-capped string ---
+export const DESCRIPTOR_MAX_WIDTH = 64;
+
+function collapseWhitespace(text: string): string {
+	return text.replace(/\s+/g, " ").trim();
+}
+
+function truncateDescriptor(text: string): string {
+	if (text.length <= DESCRIPTOR_MAX_WIDTH) return text;
+	return text.slice(0, DESCRIPTOR_MAX_WIDTH - 1).trimEnd() + "…";
+}
+
+// --- strip blobs, secrets, and sk- keys before a line reaches the header ---
+function redactNoise(text: string): string {
+	return text
+		.replace(/[A-Za-z0-9+/]{80,}={0,2}/g, "<blob>")
+		.replace(/\b((?=\w*(?:token|key|secret|password))[A-Za-z_]\w*)\s*[=:]\s*(["'])[^"']*\2/gi, "$1=<redacted>")
+		.replace(
+			/\b((?=\w*(?:token|key|secret|password))[A-Za-z_]\w*)\s*[=:]\s*(?!<redacted>)(?!["'])\S+/gi,
+			"$1=<redacted>",
+		)
+		.replace(/(["'])sk-[^"']+\1/g, "$1<redacted>$1")
+		.replace(/(["']).{160,}\1/g, "$1…$1");
+}
+
+export function descriptor(text: string): string {
+	return truncateDescriptor(collapseWhitespace(redactNoise(text)));
+}

package/src/extension/preview/index.ts

@@ -0,0 +1,39 @@
+// --- preview entry: score the whole cell for its one truthful line ---
+
+import {
+	agentCandidates,
+	bridgedToolCandidates,
+	fileCandidates,
+	genericCandidates,
+	shellCandidates,
+} from "./candidates.js";
+import { descriptor } from "./descriptor.js";
+import { stringConsts } from "./scan.js";
+import { previewShellCommand } from "./shell.js";
+import type { CellPreview } from "./types.js";
+
+export type { CellPreview };
+export { descriptor, previewShellCommand };
+
+export function previewCell(code: string): CellPreview {
+	const source = code.trimEnd();
+	if (!source) return { kind: "ts", text: "" };
+	const vars = stringConsts(source);
+
+	// --- scan order matters: agent masks shell-looking syntax before the shell scan ---
+	const agent = agentCandidates(source, vars);
+	const shell = shellCandidates(agent.masked, vars);
+	const candidates = [
+		...agent.candidates,
+		...shell.candidates,
+		...fileCandidates(shell.masked, vars),
+		...bridgedToolCandidates(shell.masked, vars),
+		...genericCandidates(shell.masked),
+	];
+
+	let best: { kind: CellPreview["kind"]; text: string; score: number } | undefined;
+	for (const candidate of candidates) {
+		if (candidate.text && (!best || candidate.score > best.score)) best = candidate;
+	}
+	return best ?? { kind: "ts", text: "" };
+}

package/src/extension/preview/scan.ts

@@ -0,0 +1,59 @@
+// --- scan: tokenizer source → template spans, string constants, and masks ---
+import { BACKTICK, type Span } from "./types.js";
+
+// --- capture the template opened at start; tracks escapes + interpolation nesting so a shell command reads whole, and an unclosed template returns the rest (partial is better than none) ---
+export function scanTemplate(source: string, start: number): Span {
+	let depth = 0;
+	let inNested = false;
+	for (let i = start + 1; i < source.length; i++) {
+		const ch = source[i];
+		if (ch === "\\") {
+			i += 1;
+			continue;
+		}
+		if (ch === BACKTICK) {
+			if (depth === 0 && !inNested) return { start, end: i + 1, body: source.slice(start + 1, i) };
+			inNested = !inNested;
+			continue;
+		}
+		if (!inNested && ch === "$" && source[i + 1] === "{") {
+			depth += 1;
+			i += 1;
+			continue;
+		}
+		if (!inNested && depth > 0 && ch === "}") depth -= 1;
+	}
+	return { start, end: source.length, body: source.slice(start + 1) };
+}
+
+const CONST_STRING_PATTERN = new RegExp(
+	'(?:const|let|var)\\s+([A-Za-z_$][\\w$]*)\\s*=\\s*(?:"([^"\\n]*)"|' +
+		"'([^'\\n]*)'|" +
+		BACKTICK +
+		"([^" +
+		BACKTICK +
+		"$\\n]*)" +
+		BACKTICK +
+		")",
+	"g",
+);
+
+// --- collected simple string constants, for resolving interpolations and path args ---
+export function stringConsts(source: string): Map<string, string> {
+	const vars = new Map<string, string>();
+	for (const match of source.matchAll(CONST_STRING_PATTERN)) {
+		const name = match[1];
+		const value = match[2] ?? match[3] ?? match[4];
+		if (name && value !== undefined) vars.set(name, value);
+	}
+	return vars;
+}
+
+export function substituteVars(text: string, vars: ReadonlyMap<string, string>): string {
+	return text.replace(/\$\{\s*([A-Za-z_$][\w$]*)\s*\}/g, (whole, name: string) => vars.get(name) ?? whole);
+}
+
+// --- blank a claimed span so later detectors don't re-read what an earlier one took ---
+export function maskSpan(source: string, span: Span): string {
+	return source.slice(0, span.start) + " ".repeat(span.end - span.start) + source.slice(span.end);
+}

package/src/extension/preview/shell.ts

@@ -0,0 +1,156 @@
+// --- shell: resolve the strongest single line of a (possibly chained) shell command ---
+import { descriptor } from "./descriptor.js";
+
+const CD_PREFIX_PATTERN = /^\s*cd\s+([^&;|]+?)\s*(?:&&|;)\s*/;
+const SHELL_SETUP_PATTERN = /^(?:export\s+\w+=|set\s+[-+]|source\s+\S+|\.\s+\S+)/;
+const HEREDOC_PATTERN = /<<-?\s*['"]?([A-Za-z_][A-Za-z0-9_]*)['"]?/;
+
+export function shellWords(line: string): string[] {
+	const words: string[] = [];
+	for (const match of line.matchAll(/"([^"]*)"|'([^']*)'|(\S+)/g)) {
+		words.push(match[1] ?? match[2] ?? match[3] ?? "");
+	}
+	return words;
+}
+
+function pathTail(path: string): string {
+	const cleaned = path.replace(/\/+$/, "");
+	const tail = cleaned.slice(cleaned.lastIndexOf("/") + 1);
+	return tail || cleaned;
+}
+
+function simplifyRunnerCommand(line: string): string | undefined {
+	const words = shellWords(line);
+	if (words[0] === "npm" || words[0] === "pnpm") {
+		const runIndex = words.indexOf("run");
+		if (runIndex >= 0 && words[runIndex + 1]) {
+			return (words[0] + " " + words.slice(runIndex + 1).join(" ")).trim();
+		}
+	}
+	if (line.includes("node_modules/.bin/")) {
+		return line.replace(/\S*node_modules\/\.bin\//g, "");
+	}
+	return undefined;
+}
+
+function simplifyMutationCommand(line: string): string | undefined {
+	const words = shellWords(line);
+	if (words.length === 0) return undefined;
+	if (words[0] === "cat" && words[1] === ">" && words[2]) return "write " + pathTail(words[2]);
+	if (words[0] === "tee" && words.at(-1)) {
+		return (words.includes("-a") ? "append " : "write ") + pathTail(words.at(-1) ?? "");
+	}
+	return undefined;
+}
+
+// --- collapse noisier command forms (runners, writes) down to the intent ---
+function simplifyShellLine(line: string): string {
+	return simplifyRunnerCommand(line) ?? simplifyMutationCommand(line) ?? line;
+}
+
+// --- commands that prepare the ground; the shell only wins when it is the story ---
+export const SHELL_SETUP_WORDS = new Set([
+	"mkdir",
+	"cd",
+	"export",
+	"touch",
+	"chmod",
+	"chown",
+	"ln",
+	"echo",
+	"true",
+	"sleep",
+	"which",
+	"sync",
+]);
+
+export const SHELL_ACTION_WORDS = new Set([
+	"rm",
+	"mv",
+	"cp",
+	"git",
+	"npm",
+	"pnpm",
+	"bun",
+	"bunx",
+	"npx",
+	"make",
+	"cargo",
+	"docker",
+	"curl",
+	"gh",
+	"pi",
+]);
+
+function shellLineScore(line: string, index: number): number {
+	const simplified = simplifyShellLine(line);
+	const words = shellWords(line);
+	let score = 30;
+	if (simplified !== line) score += 40;
+	if (SHELL_ACTION_WORDS.has(words[0] ?? "")) score += 20;
+	if (/\b(?:rm|mv|cp|git\s+(?:add|commit|push)|sed\s+-i|perl\s+-pi|tee|cat\s*>)\b/.test(line)) score += 40;
+	return score + index;
+}
+
+function heredocBody(lines: readonly string[], startIndex: number, delimiter: string): string | undefined {
+	const body: string[] = [];
+	for (let i = startIndex + 1; i < lines.length; i++) {
+		if ((lines[i] ?? "").trim() === delimiter) return body.join("\n");
+		body.push(lines[i] ?? "");
+	}
+	return body.length > 0 ? body.join("\n") : undefined;
+}
+
+function previewHeredoc(lines: readonly string[]): string | undefined {
+	for (let i = 0; i < lines.length; i++) {
+		const line = (lines[i] ?? "").trim();
+		const delimiter = line.match(HEREDOC_PATTERN)?.[1];
+		if (!delimiter) continue;
+		const body = heredocBody(lines, i, delimiter);
+		if (!body) continue;
+		// --- the write target is the story; the body is detail for the expanded view ---
+		const catWrite = line.match(/\b(?:cat|tee)\b.*(?:>|\s)(\S+)\s*<<-?/);
+		if (catWrite?.[1]) return (line.includes("tee -a") ? "append " : "write ") + pathTail(catWrite[1]);
+		return descriptor(body);
+	}
+	return undefined;
+}
+
+export function previewShellCommand(command: string): string {
+	return previewShellCommandScored(command).text;
+}
+
+// --- like previewShellCommand but keeps the winning line's strength so several shell calls can rank ---
+export function previewShellCommandScored(command: string): { text: string; strength: number } {
+	const lines = command.split("\n");
+	const heredoc = previewHeredoc(lines);
+	if (heredoc) return { text: descriptor(heredoc), strength: 90 };
+
+	let best: { text: string; score: number } | undefined;
+	let cwdSuffix: string | undefined;
+	let index = 0;
+	for (const rawLine of lines) {
+		for (const rawPart of rawLine.split(/\s*(?:&&|;)\s*/)) {
+			let part = rawPart.trim();
+			if (!part || part.startsWith("#") || SHELL_SETUP_PATTERN.test(part)) continue;
+			const cd = part.match(CD_PREFIX_PATTERN);
+			if (cd?.[1]) {
+				cwdSuffix = pathTail(cd[1].trim());
+				part = part.replace(CD_PREFIX_PATTERN, "").trim();
+			} else if (/^cd\s+\S+$/.test(part)) {
+				cwdSuffix = pathTail(part.slice(2).trim());
+				continue;
+			}
+			if (!part) continue;
+			const candidate = { text: simplifyShellLine(part), score: shellLineScore(part, index) };
+			if (!best || candidate.score > best.score) best = candidate;
+			index += 1;
+		}
+	}
+	if (!best) return { text: "", strength: 0 };
+	// --- trailing redirections are plumbing, not intent ---
+	const cleaned = best.text.replace(/(?:\s*(?:2>&1|[12]?>\s*\/dev\/null|&>\s*\/dev\/null))+\s*$/, "");
+	// --- a stripped cd prefix still matters when it names a non-default dir ---
+	const text = cwdSuffix && !cleaned.includes(cwdSuffix) ? cleaned + " (" + cwdSuffix + ")" : cleaned;
+	return { text: descriptor(text), strength: best.score };
+}

package/src/extension/preview/types.ts

@@ -0,0 +1,23 @@
+// --- shared preview types; tiny module so every consumer imports only the shape it needs ---
+export type CellPreviewKind = "shell" | "agent" | "ts";
+
+export interface CellPreview {
+	kind: CellPreviewKind;
+	text: string;
+}
+
+// --- a [start, end) slice of the source with its captured body ---
+export interface Span {
+	start: number;
+	end: number;
+	body: string;
+}
+
+// --- the winner of each detector, ranked by score in the orchestration ---
+export interface Candidate {
+	kind: CellPreviewKind;
+	text: string;
+	score: number;
+}
+
+export const BACKTICK = "\u0060";