pi-shorthand 0.6.0 → 0.7.1

package/api.d.ts

@@ -8,7 +8,7 @@ declare global {
 	const grep: ShorthandGlobals["grep"];
 	const sg: ShorthandGlobals["sg"];
 	const grit: ShorthandGlobals["grit"];
-	const ts: ShorthandGlobals["ts"];
+	const refactor: ShorthandGlobals["refactor"];
 }
 
 export type { RewriteResult } from "./prelude.ts";

package/display.ts

@@ -93,7 +93,7 @@ export function resultLines(run: RunResult, expanded: boolean, theme: Theme): st
 	for (const section of sections) lines.push("", ...section);
 	const timing = timingBreakdown(run);
 	if (timing) lines.push("", theme.fg("muted", `timing: ${timing}`));
-	if (run.diagnostics && ((run.diagnostics.wallMs ?? run.durationMs) >= run.timeoutMs || run.exitCode !== 0)) {
+	if (run.diagnostics && ((run.diagnostics.wallMs ?? run.durationMs) >= timeoutBudgetMs(run) || run.exitCode !== 0)) {
 		lines.push(...diagnosticLines(run.diagnostics).map((line) => theme.fg("muted", line)));
 	}
 	return lines;
@@ -115,7 +115,7 @@ const TIMING_LABELS: Record<keyof RunTimings, string> = {
 
 /** Explain calls exceeding the configured program budget, even when no individual phase does. */
 export function timingBreakdown(run: RunResult): string | undefined {
-	if (!run.timings || (run.diagnostics?.wallMs ?? run.durationMs) < run.timeoutMs) return undefined;
+	if (!run.timings || (run.diagnostics?.wallMs ?? run.durationMs) < timeoutBudgetMs(run)) return undefined;
 	const significant = Object.entries(run.timings)
 		.map(([phase, milliseconds]) => ({
 			label: TIMING_LABELS[phase as keyof RunTimings],
@@ -131,16 +131,27 @@ function formatDuration(milliseconds: number): string {
 	return milliseconds < 1_000 ? `${milliseconds}ms` : `${(milliseconds / 1_000).toFixed(1)}s`;
 }
 
+/** e.g. "2s" or "2s plus 60.0s in helpers": helper time does not count toward the timeout. */
+function timeoutText(run: RunResult): string {
+	const helpers = run.helperMs ? ` plus ${formatDuration(run.helperMs)} in helpers` : "";
+	return `${run.timeoutMs / 1000}s${helpers}`;
+}
+
+/** The longest a run can take before its timeout, including excluded helper time. */
+export function timeoutBudgetMs(run: RunResult): number {
+	return run.timeoutMs + (run.helperMs ?? 0);
+}
+
 /** e.g. "✓ Applied 3 files · +6 −6 · 0.6s" or "✕ Failed · rolled back all changes · exit 1 · 0.2s" */
 function verdict(run: RunResult, applied: FileChange[], theme: Theme): string {
 	const muted = (text: string) => theme.fg("muted", text);
 	const took = muted(` · ${(run.durationMs / 1000).toFixed(1)}s`);
-	const failure = run.timedOut ? `Program timed out after ${run.timeoutMs / 1000}s` : "Failed";
+	const failure = run.timedOut ? `Program timed out after ${timeoutText(run)}` : "Failed";
 	const exit = run.timedOut ? "" : muted(` · exit ${run.exitCode}`);
 
 	if (run.conflicts.length > 0) {
 		const program = run.timedOut
-			? ` · timed out after ${run.timeoutMs / 1000}s`
+			? ` · timed out after ${timeoutText(run)}`
 			: run.exitCode
 				? ` · exit ${run.exitCode}`
 				: "";

package/format.ts

@@ -117,14 +117,26 @@ export function formatterFor(file: string, root: string): Command | null {
 	return null;
 }
 
+/** Files of one kind share a formatter decision: JS-family files, Python, Go or Rust. */
+function formatterKind(file: string): string {
+	const extension = extname(file);
+	if (/\.(?:[cm]?[jt]sx?|jsonc?|css|scss|less|html|vue|svelte|mdx?|ya?ml|graphql)$/i.test(extension)) return "js";
+	return extension === ".pyi" ? ".py" : extension;
+}
+
 export async function formatChanged(
 	files: string[],
 	root: string,
 ): Promise<{ messages: string[]; warnings: string[] }> {
 	const groups = new Map<string, { command: Command; files: string[] }>();
 	const result = { messages: [] as string[], warnings: [] as string[] };
+	// The choice depends only on a file's directory and kind of source, and each lookup checks several
+	// config files per ancestor directory, so decide once for files that share both.
+	const decided = new Map<string, Command | null>();
 	for (const file of files) {
-		const command = formatterFor(file, root);
+		const place = `${dirname(resolve(root, file))}\0${formatterKind(file)}`;
+		if (!decided.has(place)) decided.set(place, formatterFor(file, root));
+		const command = decided.get(place)!;
 		if (!command) continue;
 		const key = JSON.stringify(command);
 		const group = groups.get(key) ?? { command, files: [] };

package/index.ts

@@ -17,11 +17,13 @@ import {
 	countLines,
 	fileMetadataSummary,
 	resultLines,
+	timeoutBudgetMs,
 	timingBreakdown,
 	unstructuredResultText,
 } from "./display.ts";
 import type { FileChange, RunOptions, RunResult } from "./runner.ts";
 import { type Diagnostics, completeDiagnostics, diagnosticLines } from "./diagnostics.ts";
+import { modelDiff } from "./model-diff.ts";
 
 class RunnerError extends Error {
 	constructor(
@@ -35,7 +37,7 @@ class RunnerError extends Error {
 // Runs typically take well under a second. Longer transformations can request more time.
 const DEFAULT_TIMEOUT_SECONDS = 2;
 
-const DESCRIPTION = `Edit repository files with a TypeScript program run by Bun. Top-level await and ordinary Bun/Node APIs work. Use repository-relative paths. Set cwd to a checkout path when Pi's working directory is outside the repository, such as a child worktree in a bare worktree container. The program runs in an isolated workspace; changes apply on successful exit by default and the tool reports the diff. Run tests, type-checks and builds separately afterward with the shell tool.
+const DESCRIPTION = `Edit repository files with a TypeScript program run by Bun. Best for changes across many files, repeated edits and semantic TypeScript renames or moves; a small change to one file is quicker as a direct edit. Top-level await and ordinary Bun/Node APIs work. Use repository-relative paths. Set cwd to a checkout path when Pi's working directory is outside the repository, such as a child worktree in a bare worktree container. The program runs in an isolated workspace; changes apply on successful exit by default and the tool reports the diff. Run tests, type-checks and builds separately afterward with the shell tool.
 
 Common operations:
 - edit({ path, oldText, newText }) replaces exactly one literal occurrence; missing or ambiguous text is an error. Use text edits for known source, structural matching when it saves enumerating occurrences or preserves varying syntax.
@@ -43,10 +45,11 @@ Common operations:
 - sg.rewrite(pattern, replacement, files?) discovers and rewrites matching code; omit files for the working directory. $X captures one node; $$$X captures a sequence.
 - sg.one(pattern, files?) selects exactly one match; sg.find returns an array. sg.rewrite also accepts a selected match or array without a file scope.
 - A rewrite callback receives a match and returns text, a native node.replace(text) edit, or null to skip. Return native edits to apply them. Pass selected arrays together for independent edits; select again after changing their file.
-- await ts.rename({ file, symbol, to }) renames one resolved TypeScript symbol across the project without changing unrelated names.
-- await ts.renameFile({ from, to }) moves a TypeScript file and updates module paths that resolve to it.
+- await refactor.rename({ file, symbol, to }) renames one resolved TypeScript symbol across the project without changing unrelated names.
+- await refactor.renameFile({ from, to }) moves a TypeScript file and updates module paths that resolve to it.
+- await refactor.move({ file, symbol, to }) moves a top-level declaration to another file and updates the imports that follow it.
 
-See the shorthand skill for common writes. For extraction, complex rewrites or other languages, read its advanced-refactors.md guide. The default timeout is two seconds; request more for longer programs.`;
+See the shorthand skill for renames, moves and call-site migrations. Read its advanced-refactors.md guide only to extract code, move syntax, use GritQL or edit other languages. The default timeout is two seconds; request more for longer programs. Time spent inside the helpers above does not count toward it, up to 60 extra seconds.`;
 
 export default function (pi: ExtensionAPI) {
 	// A failed run is an error, both for the model and for how Pi shows it. (execute() returns its details
@@ -65,7 +68,8 @@ export default function (pi: ExtensionAPI) {
 		name: "code",
 		label: "Code",
 		description: DESCRIPTION,
-		promptSnippet: "Make a change with one Bun editing program; run verification separately afterward",
+		promptSnippet:
+			"Make multi-file, repetitive or rename/move changes with one Bun program; a small change to one file is quicker as a direct edit. Run verification separately afterward",
 
 		parameters: Type.Object({
 			title: Type.String({ description: "A few words describing the change, shown to the user" }),
@@ -82,7 +86,11 @@ export default function (pi: ExtensionAPI) {
 						'On failure: "file" (default) rolls back failed or interrupted file edits and retains the others; "all" applies nothing',
 				}),
 			),
-			timeout: Type.Optional(Type.Number({ description: "Seconds before the program is killed (default 2)" })),
+			timeout: Type.Optional(
+				Type.Number({
+					description: "Seconds of program time before it is killed (default 2); time inside helpers is excluded",
+				}),
+			),
 		}),
 
 		async execute(toolCallId, params, signal, onUpdate, ctx) {
@@ -313,7 +321,7 @@ function textForModel(run: RunResult, toolCallId: string): string {
 	// On failure the error goes last, where it's easiest to find; on success, the diff does.
 	if (run.exitCode === 0 && run.conflicts.length === 0) lines.push(...output, ...diff);
 	else lines.push(...diff, ...output);
-	if (run.diagnostics && ((run.diagnostics.wallMs ?? run.durationMs) >= run.timeoutMs || run.exitCode !== 0))
+	if (run.diagnostics && ((run.diagnostics.wallMs ?? run.durationMs) >= timeoutBudgetMs(run) || run.exitCode !== 0))
 		lines.push("", ...diagnosticLines(run.diagnostics));
 	return lines.join("\n");
 }
@@ -336,13 +344,17 @@ function diffForModel(run: RunResult, toolCallId: string): string[] {
 	const diff = run.changes.map((change) => change.patch).join("\n");
 	if (!diff) return [];
 
-	const truncated = truncateHead(diff);
+	// A large diff is shown as one example of each distinct change, then cut to Pi's usual limits.
+	const shown = modelDiff(run.changes);
+	const truncated = truncateHead(shown.text);
 	const lines = ["", truncated.content];
-	if (truncated.truncated) {
+	if (shown.summarized || truncated.truncated) {
 		const fullDiffPath = path.join(tmpdir(), `pi-shorthand-${toolCallId}.diff`);
 		writeFileSync(fullDiffPath, diff);
 		lines.push(
-			`[diff truncated at ${truncated.outputLines} of ${truncated.totalLines} lines; full diff: ${fullDiffPath}]`,
+			truncated.truncated
+				? `[diff truncated at ${truncated.outputLines} of ${truncated.totalLines} lines; full diff: ${fullDiffPath}]`
+				: `[full diff: ${fullDiffPath}]`,
 		);
 	}
 	return lines;

package/linux-observer.c

@@ -94,17 +94,20 @@ static void capture(const char *file, char kind) {
     if (*relative == '/') relative++;
     request(kind, *relative ? relative : ".", "");
 }
-static void trace_string(pid_t pid, uint64_t address, char result[PATH_MAX]) {
+/* Returns 0 when the stopped thread is gone (ESRCH): SIGKILL or a sibling's exec retired it, so the syscall it
+ * stopped in never executes and there is nothing to observe. */
+static int trace_string(pid_t pid, uint64_t address, char result[PATH_MAX]) {
     for (size_t offset = 0; offset < PATH_MAX;) {
         uintptr_t location = address + offset;
         size_t skip = location % sizeof(long);
         errno = 0;
         long word = ptrace(PTRACE_PEEKDATA, pid, (void *)(location - skip), 0);
+        if (errno == ESRCH) return 0;
         if (errno) die("cannot inspect syscall path");
         size_t count = sizeof(word) - skip;
         if (count > PATH_MAX - offset) count = PATH_MAX - offset;
         memcpy(result + offset, (char *)&word + skip, count);
-        if (memchr((char *)&word + skip, 0, count)) return;
+        if (memchr((char *)&word + skip, 0, count)) return 1;
         offset += count;
     }
     die("overlong syscall path");
@@ -267,8 +270,7 @@ static void resolve_name(pid_t pid, int fd, const char *input, int follow, char
 }
 static void resolve_path(pid_t pid, int fd, uint64_t address, int follow, char result[PATH_MAX]) {
     char input[PATH_MAX];
-    if (!address) { result[0] = 0; return; }
-    trace_string(pid, address, input);
+    if (!address || !trace_string(pid, address, input)) { result[0] = 0; return; }
     resolve_name(pid, fd, input, follow, result);
 }
 

package/lsp-client.ts

@@ -87,6 +87,9 @@ async function startTypeScriptServer(root: string): Promise<TypeScriptServer> {
 		await connection.sendRequest("initialize", {
 			processId: process.pid,
 			rootUri: pathToFileURL(root).href,
+			// Rename without aliases: by default a renamed declaration is re-exported as `new as old`, so importers
+			// through a barrel keep the old name. typescript-refactors.ts keeps object literal keys unchanged instead.
+			initializationOptions: { userPreferences: { providePrefixAndSuffixTextForRename: false } },
 			capabilities: {
 				workspace: {
 					workspaceEdit: { documentChanges: true },

package/model-diff.ts

@@ -0,0 +1,60 @@
+/**
+ * The diff the model reads after a run. Small diffs are shown whole. A large diff is usually one kind of
+ * change repeated across many files, so it is shown as one example of each kind, with how many files share
+ * it; the per-file list and a path to the whole diff come with it. What people see in Pi is rendered from
+ * the result's details, not from this text.
+ */
+import type { FileChange } from "./runner.ts";
+
+/** Diffs up to this size are shown whole: about 4,000 tokens. */
+export const WHOLE_DIFF_CHARS = 16_000;
+
+/** Changed lines, ignoring numbers and string contents, which usually differ between repeated edits. */
+export function changeKind(patch: string): string {
+	return patch
+		.split("\n")
+		.filter((line) => /^[+-]/.test(line) && !/^(?:\+\+\+|---) /.test(line))
+		.map((line) =>
+			line
+				.replace(/"(?:[^"\\]|\\.)*"|'(?:[^'\\]|\\.)*'|`(?:[^`\\]|\\.)*`/g, '""')
+				.replace(/\d+/g, "0")
+				.trim(),
+		)
+		.join("\n");
+}
+
+export interface ModelDiff {
+	text: string;
+	/** True when some files are represented by an example rather than shown. */
+	summarized: boolean;
+}
+
+export function modelDiff(changes: FileChange[], budget = WHOLE_DIFF_CHARS): ModelDiff {
+	const whole = changes.map((change) => change.patch).join("\n");
+	if (whole.length <= budget) return { text: whole, summarized: false };
+
+	const kinds = new Map<string, FileChange[]>();
+	for (const change of changes) {
+		const kind = `${change.kind}\0${changeKind(change.patch)}`;
+		kinds.set(kind, [...(kinds.get(kind) ?? []), change]);
+	}
+	// Rarer kinds first: an unusual edit is more likely to be the mistake worth seeing.
+	const groups = [...kinds.values()].toSorted((a, b) => a.length - b.length);
+	const sections: string[] = [];
+	let used = 0;
+	let omitted = 0;
+	for (const [example, ...same] of groups) {
+		const section = [
+			example!.patch,
+			...(same.length ? [`(and ${same.length} more file${same.length === 1 ? "" : "s"} with the same change)`] : []),
+		].join("\n");
+		if (sections.length > 0 && used + section.length > budget) {
+			omitted += 1 + same.length;
+			continue;
+		}
+		sections.push(section);
+		used += section.length;
+	}
+	const header = `[${changes.length} files changed in ${groups.length} distinct way${groups.length === 1 ? "" : "s"}; one example of each is shown${omitted ? `, except ${omitted} file${omitted === 1 ? "" : "s"} over the size limit` : ""}]`;
+	return { text: [header, ...sections].join("\n"), summarized: true };
+}