pi-shorthand 0.8.0 → 0.10.0

package/README.md

@@ -1,16 +1,21 @@
 # pi-shorthand
 
-![A code call in Pi](https://raw.githubusercontent.com/sebinsua/pi-shorthand/main/docs/screenshot.png?v=2)
+![A code call in Pi](https://raw.githubusercontent.com/sebinsua/shortsight/main/docs/shorthand.png)
 
 A [Pi](https://github.com/earendil-works/pi) tool for editing repositories with Bun programs, with first-class support for TypeScript and JavaScript.
 
 ## Install
 
-Install pi-shorthand and initialize Grit:
+Install [Bun](https://bun.sh) 1.4 or later, which runs the programs:
+
+```sh
+curl -fsSL https://bun.sh/install | bash
+```
+
+Then install pi-shorthand:
 
 ```sh
 pi install npm:pi-shorthand
-npx @getgrit/cli init --global
 ```
 
 On macOS, install clang and AgentFS:
@@ -31,6 +36,18 @@ sudo apt install bubblewrap build-essential lsof
 
 pi-shorthand gives Pi a programming environment instead of a patch format. This makes multi-file and structural edits possible in one call, but does not guarantee that Pi will find it easier or more reliable than its built-in edit tool. Which works better depends on the model and the task.
 
-Programs edit a private workspace, with host files outside the repository kept read-only. By default, a failure keeps completed files and rolls back failed or interrupted edits. Concurrent edits can cause a run to be rejected; conflict detection is best-effort, not an atomic commit.
+Programs edit a private workspace, with host files outside the repository kept read-only. Agents are good at improving things a step at a time, so changes are applied a whole file at a time and the agent is told which worked and which didn't. Concurrent edits can cause a run to be rejected; conflict detection is best-effort, not an atomic commit.
 
 The `code` tool uses Pi's working directory by default. Pass `cwd` to target another checkout; relative paths are resolved from Pi's working directory. For example, when Pi starts in a bare worktree container, `cwd: "child"` targets its `child` worktree. The chosen directory must be inside a Git worktree.
+
+## Without Pi
+
+The engine is published separately as [shorthand-code](https://github.com/sebinsua/shortsight/tree/main/packages/shorthand-code), with a `shorthand` command that runs a program from a file or stdin and prints the same result. See `shorthand --help`.
+
+## Code graph (optional)
+
+Install [`sightread`](https://github.com/sebinsua/shortsight/tree/main/packages/sightread) and programs can also ask the TypeScript compiler what calls what, with exact line ranges, before they edit:
+
+```sh
+npm i -g sightread
+```

package/package.json

@@ -1,58 +1,32 @@
 {
 	"name": "pi-shorthand",
-	"version": "0.8.0",
+	"version": "0.10.0",
 	"description": "Pi tool for editing repositories with Bun programs, with first-class support for TypeScript and JavaScript.",
 	"keywords": [
 		"ast-grep",
 		"bun",
 		"code-mode",
-		"gritql",
 		"overlay",
 		"pi",
 		"pi-extension",
 		"pi-package"
 	],
-	"homepage": "https://github.com/sebinsua/pi-shorthand#readme",
-	"bugs": "https://github.com/sebinsua/pi-shorthand/issues",
+	"homepage": "https://github.com/sebinsua/shortsight/tree/main/packages/pi-shorthand#readme",
+	"bugs": "https://github.com/sebinsua/shortsight/issues",
 	"license": "MIT",
 	"author": "Seb Insua",
 	"repository": {
 		"type": "git",
-		"url": "git+https://github.com/sebinsua/pi-shorthand.git"
+		"url": "git+https://github.com/sebinsua/shortsight.git",
+		"directory": "packages/pi-shorthand"
 	},
 	"files": [
-		"*.c",
-		"*.ts",
-		"skills",
+		"src",
 		"README.md"
 	],
 	"type": "module",
-	"scripts": {
-		"test": "bun test",
-		"typecheck": "tsc -p .",
-		"lint": "oxlint --deny-warnings",
-		"format": "oxfmt",
-		"check": "tsc -p . && oxlint --deny-warnings && oxfmt --check",
-		"setup:grit": "grit init --global",
-		"prepare": "git config core.hooksPath .githooks 2>/dev/null || true"
-	},
 	"dependencies": {
-		"@ast-grep/cli": "^0.45.3",
-		"@ast-grep/napi": "^0.45.3",
-		"@getgrit/cli": "0.1.0-alpha.1743007075",
-		"diff": "^9.0.0",
-		"typescript": "7.0.2",
-		"vscode-jsonrpc": "^9.0.2"
-	},
-	"devDependencies": {
-		"@earendil-works/pi-ai": "^0.85.1",
-		"@earendil-works/pi-coding-agent": "^0.85.1",
-		"@earendil-works/pi-tui": "^0.85.1",
-		"@types/bun": "^1.4.2",
-		"@types/node": "^26.6.1",
-		"oxfmt": "^0.68.0",
-		"oxlint": "^1.83.0",
-		"typebox": "^1.3.7"
+		"shorthand-code": "0.10.0"
 	},
 	"peerDependencies": {
 		"@earendil-works/pi-ai": "*",
@@ -74,13 +48,13 @@
 			"optional": true
 		}
 	},
+	"engines": {
+		"bun": ">=1.4"
+	},
 	"pi": {
 		"extensions": [
-			"./index.ts"
-		],
-		"skills": [
-			"./skills"
+			"./src/index.ts"
 		],
-		"image": "https://raw.githubusercontent.com/sebinsua/pi-shorthand/main/docs/screenshot.png?v=2"
+		"image": "https://raw.githubusercontent.com/sebinsua/shortsight/main/docs/shorthand.png"
 	}
 }

package/{display.ts → src/display.ts}

@@ -8,8 +8,16 @@
  */
 
 import { getLanguageFromPath, highlightCode, keyHint, renderDiff, type Theme } from "@earendil-works/pi-coding-agent";
-import type { FileChange, RunResult, RunTimings } from "./runner.ts";
-import { diagnosticLines } from "./diagnostics.ts";
+import {
+	type FileChange,
+	type RunResult,
+	countLines,
+	diagnosticLines,
+	fileMetadataSummary,
+	timeoutBudgetMs,
+	timeoutText,
+	timingBreakdown,
+} from "shorthand-code";
 
 type ToolBackground = "toolSuccessBg" | "toolErrorBg";
 
@@ -99,49 +107,6 @@ export function resultLines(run: RunResult, expanded: boolean, theme: Theme): st
 	return lines;
 }
 
-const TIMING_LABELS: Record<keyof RunTimings, string> = {
-	resolveRepositoryMs: "repository",
-	waitForLockMs: "lock wait",
-	workspaceSetupMs: "workspace setup",
-	programMs: "program",
-	scanChangesMs: "change scan",
-	formatMs: "formatter",
-	workspaceCloseMs: "workspace cleanup",
-	checkConflictsMs: "conflict check",
-	applyMs: "apply",
-	renderDiffMs: "diff",
-	unattributedMs: "other",
-};
-
-/** 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) < timeoutBudgetMs(run)) return undefined;
-	const significant = Object.entries(run.timings)
-		.map(([phase, milliseconds]) => ({
-			label: TIMING_LABELS[phase as keyof RunTimings],
-			milliseconds,
-		}))
-		.filter(({ milliseconds }) => milliseconds > 0)
-		.toSorted((a, b) => b.milliseconds - a.milliseconds);
-	if (significant.length === 0) return undefined;
-	return significant.map(({ label, milliseconds }) => `${label} ${formatDuration(milliseconds)}`).join(" · ");
-}
-
-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);
@@ -369,17 +334,6 @@ function fileLine(change: FileChange, theme: Theme): string {
 	return `${theme.fg("accent", change.path)}${kind}${metadata ? theme.fg("muted", ` (${metadata})`) : ""} ${stats([change], theme)}`;
 }
 
-export function fileMetadataSummary(change: FileChange): string {
-	if (change.beforeType && change.afterType && change.beforeType !== change.afterType) {
-		return `${change.beforeType} → ${change.afterType}`;
-	}
-	if (change.afterType === "symlink" && change.beforeType !== "symlink") return "symlink";
-	if (change.beforeMode !== undefined && change.afterMode !== undefined && change.beforeMode !== change.afterMode) {
-		return `${change.beforeMode.toString(8)} → ${change.afterMode.toString(8)}`;
-	}
-	return "";
-}
-
 /** "+6 −2", in the diff colours. */
 function stats(changes: FileChange[], theme: Theme): string {
 	const counts = changes.map((change) => countLines(change.patch));
@@ -434,16 +388,3 @@ function toPiDiff(patch: string): string {
 	}
 	return out.join("\n");
 }
-
-/** Added and removed lines in a patch. Only lines after the first "@@" count, not the ---/+++ headers. */
-export function countLines(patch: string) {
-	let additions = 0;
-	let deletions = 0;
-	let inHunks = false;
-	for (const line of patch.split("\n")) {
-		if (line.startsWith("@@")) inHunks = true;
-		else if (inHunks && line.startsWith("+")) additions++;
-		else if (inHunks && line.startsWith("-")) deletions++;
-	}
-	return { additions, deletions };
-}

package/src/index.ts

@@ -0,0 +1,174 @@
+/**
+ * The `code` tool: the model writes one Bun program that makes a multi-step change to the repository.
+ * Its writes go to a copy-on-write overlay; if it succeeds, they're applied and the diff is returned.
+ */
+
+import { createRequire } from "node:module";
+import * as path from "node:path";
+import { StringEnum } from "@earendil-works/pi-ai";
+import { type ExtensionAPI, type Theme, truncateHead, truncateTail } from "@earendil-works/pi-coding-agent";
+import { Text } from "@earendil-works/pi-tui";
+import { Type } from "typebox";
+import {
+	DEFAULT_TIMEOUT_SECONDS,
+	type Diagnostics,
+	type RunResult,
+	RunnerError,
+	diagnosticLines,
+	runFailed,
+	runWithBun,
+	sightreadAvailable,
+	textForModel,
+} from "shorthand-code";
+import { callLine, resultLines, unstructuredResultText } from "./display.ts";
+
+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.
+- await Bun.file(path).text(); await Bun.write(path, text)
+- 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 refactor.rename({ file, symbol, to }) renames one resolved TypeScript symbol across the project without changing unrelated names.
+- await refactor.references({ file, symbol }) returns resolved identifier matches that pass straight to sg.rewrite(matches, callback).
+- 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 renames, moves and call-site migrations. Read its advanced-refactors.md guide only to extract code, move syntax or use rule objects. 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.`;
+
+const GRAPH_DESCRIPTION =
+	"- await graph.query(request | request[]) queries symbols and relationships; graph results can be passed to sg as scope. The graph shows the repository before this program's edits.\n";
+
+export const SKILLS_DIRECTORY = path.join(
+	path.dirname(createRequire(import.meta.url).resolve("shorthand-code/package.json")),
+	"skills",
+);
+
+export function codeDescription(graphAvailable: boolean): string {
+	return graphAvailable
+		? DESCRIPTION.replace("\n\nSee the shorthand skill", `\n${GRAPH_DESCRIPTION}\nSee the shorthand skill`)
+		: DESCRIPTION;
+}
+
+export default async function (pi: ExtensionAPI, findGraph: () => Promise<unknown> = sightreadAvailable) {
+	// The shorthand skill ships with shorthand-code, whose `shorthand --skill` prints it for other agents.
+	pi.on("resources_discover", () => ({ skillPaths: [SKILLS_DIRECTORY] }));
+	const graphAvailable = Boolean(await findGraph());
+	// A failed run is an error, both for the model and for how Pi shows it. (execute() returns its details
+	// rather than throwing, since a thrown error loses them.)
+	pi.on("tool_result", async (event) => {
+		const run = event.details as RunResult | undefined;
+		if (event.toolName === "code" && run && runFailed(run)) return { isError: true };
+	});
+
+	pi.registerTool({
+		name: "code",
+		label: "Code",
+		description: codeDescription(graphAvailable),
+		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" }),
+			program: Type.String({ description: "TypeScript program run with Bun (top-level await allowed)" }),
+			cwd: Type.Optional(
+				Type.String({
+					description:
+						"Working directory for the program; relative to Pi's working directory, or an absolute path. Defaults to Pi's working directory. Must be inside a git worktree.",
+				}),
+			),
+			rollback: Type.Optional(
+				StringEnum(["all", "file"] as const, {
+					description:
+						'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 of program time before it is killed (default 2); time inside helpers is excluded",
+				}),
+			),
+		}),
+
+		async execute(toolCallId, params, signal, onUpdate, ctx) {
+			// While it runs, show how long it's been going and the latest reported step.
+			const startedAt = Date.now();
+			let latest: string | undefined;
+			const progress = setInterval(() => {
+				const elapsed = `${((Date.now() - startedAt) / 1000).toFixed(1)} s`;
+				onUpdate?.({
+					content: [{ type: "text", text: "running" }],
+					details: { progress: latest ? `${elapsed} · ${latest}` : elapsed },
+				});
+			}, 500);
+
+			let result: RunResult;
+			try {
+				result = await runWithBun(
+					{
+						cwd: path.resolve(ctx.cwd, params.cwd ?? "."),
+						program: params.program,
+						timeoutMs: (params.timeout ?? DEFAULT_TIMEOUT_SECONDS) * 1000,
+						rollback: params.rollback ?? "file",
+						graph: graphAvailable,
+					},
+					signal,
+					(step) => (latest = step),
+				);
+			} catch (error) {
+				if (!(error instanceof RunnerError)) throw error;
+				return {
+					isError: true,
+					content: [{ type: "text" as const, text: [error.message, ...diagnosticLines(error.diagnostics)].join("\n") }],
+					details: { infrastructureError: error.message, diagnostics: error.diagnostics },
+				};
+			} finally {
+				clearInterval(progress);
+			}
+			return {
+				content: [
+					{
+						type: "text",
+						text: textForModel(result, { name: `pi-shorthand-${toolCallId}`, truncateHead, truncateTail }),
+					},
+				],
+				details: result,
+			};
+		},
+
+		renderCall(args, theme) {
+			return new Text(callLine(args, theme), 0, 0);
+		},
+
+		renderResult(result, options, theme) {
+			return renderCodeResult(result, options, theme);
+		},
+	});
+}
+
+export function renderCodeResult(
+	result: { content: readonly unknown[]; details?: unknown },
+	{ expanded, isPartial }: { expanded: boolean; isPartial: boolean },
+	theme: Theme,
+): Text {
+	if (isPartial) {
+		const progress = (result.details as { progress?: string } | undefined)?.progress;
+		return new Text(theme.fg("muted", progress ? `running… ${progress}` : "running…"), 0, 0);
+	}
+	if (result.details && typeof result.details === "object" && "infrastructureError" in result.details) {
+		const failure = result.details as { infrastructureError: string; diagnostics: Diagnostics };
+		return new Text(
+			[
+				theme.fg("error", failure.infrastructureError),
+				"",
+				...diagnosticLines(failure.diagnostics).map((line) => theme.fg("muted", line)),
+			].join("\n"),
+			0,
+			0,
+		);
+	}
+	const run = result.details as RunResult | undefined;
+	if (!run) return new Text(theme.fg("error", unstructuredResultText(result.content)), 0, 0);
+	return new Text(resultLines(run, expanded, theme).join("\n"), 0, 0);
+}

package/agentfs-database.ts

@@ -1,141 +0,0 @@
-/** Reuse only pristine, never-mounted AgentFS databases; each run gets independent copies. */
-import { createHash } from "node:crypto";
-import * as fs from "node:fs/promises";
-import { constants } from "node:fs";
-import { homedir } from "node:os";
-import * as path from "node:path";
-import { $ } from "bun";
-import { Database } from "bun:sqlite";
-
-async function ownedDirectory(directory: string): Promise<void> {
-	await fs.mkdir(directory, { recursive: true, mode: 0o700 });
-	const stat = await fs.lstat(directory);
-	if (!stat.isDirectory() || stat.isSymbolicLink() || stat.uid !== process.getuid?.() || stat.mode & 0o077)
-		throw new Error(`Unsafe AgentFS template directory: ${directory}`);
-}
-
-async function templateKey(agentfs: string, repo: string): Promise<string> {
-	const executable = await fs.stat(agentfs, { bigint: true });
-	const repository = await fs.stat(repo, { bigint: true });
-	// Do not tie the template to checkout contents: it contains schema and the base
-	// path, not source files. Replacing either the executable or root invalidates it.
-	return createHash("sha256")
-		.update(
-			JSON.stringify(
-				[
-					1,
-					process.getuid?.(),
-					process.getgid?.(),
-					agentfs,
-					executable.dev,
-					executable.ino,
-					executable.size,
-					executable.mtimeNs,
-					executable.ctimeNs,
-					repo,
-					repository.dev,
-					repository.ino,
-				],
-				(_, value) => (typeof value === "bigint" ? String(value) : value),
-			),
-		)
-		.digest("hex");
-}
-
-async function copyTemplate(template: string, destination: string): Promise<void> {
-	const directory = await fs.lstat(template);
-	if (
-		!directory.isDirectory() ||
-		directory.isSymbolicLink() ||
-		directory.uid !== process.getuid?.() ||
-		directory.mode & 0o077
-	)
-		throw new Error("Unsafe AgentFS database template");
-	const names = await fs.readdir(template);
-	if (!names.includes("run.db")) throw new Error("Incomplete AgentFS database template");
-	await fs.mkdir(destination, { recursive: true, mode: 0o700 });
-	for (const name of names) {
-		const source = path.join(template, name);
-		const stat = await fs.lstat(source);
-		if (
-			!(name === "run.db" || name === "run.db-wal") ||
-			!stat.isFile() ||
-			stat.uid !== process.getuid?.() ||
-			stat.mode & 0o077 ||
-			stat.nlink !== 1
-		)
-			throw new Error("Unsafe AgentFS database template entry");
-		// No hardlinks: serving a transaction must never mutate the template.
-		await fs.copyFile(source, path.join(destination, name), constants.COPYFILE_EXCL);
-	}
-}
-
-/** Inspect the private copy, so SQLite never opens or modifies the shared template. */
-function validateEmptyDatabase(file: string, repo: string): void {
-	const db = new Database(file, { readonly: true, strict: true });
-	try {
-		const base = db.query("SELECT value FROM fs_overlay_config WHERE key = 'base_path'").get() as
-			| { value: string }
-			| undefined;
-		const root = db.query("SELECT mode, uid, gid FROM fs_inode WHERE ino = 1").get() as
-			| { mode: number; uid: number; gid: number }
-			| undefined;
-		if (
-			base?.value !== repo ||
-			!root ||
-			(root.mode & 0o170000) !== 0o040000 ||
-			root.uid !== process.getuid?.() ||
-			root.gid !== process.getgid?.()
-		)
-			throw new Error("AgentFS template has the wrong base or root identity");
-		for (const table of ["fs_dentry", "fs_whiteout", "fs_origin", "fs_data", "fs_symlink", "kv_store", "tool_calls"]) {
-			const count = db.query(`SELECT COUNT(*) AS count FROM ${table}`).get() as { count: number };
-			if (count.count !== 0) throw new Error(`AgentFS template contains private ${table} state`);
-		}
-		const inodes = db.query("SELECT COUNT(*) AS count FROM fs_inode").get() as { count: number };
-		if (inodes.count !== 1) throw new Error("AgentFS template contains private inode state");
-	} finally {
-		db.close();
-	}
-}
-
-export async function createAgentFsDatabase(
-	agentfs: string,
-	base: string,
-	tempDir: string,
-	cache = path.join(homedir(), ".cache", "pi-shorthand", "agentfs-templates"),
-): Promise<string> {
-	const executable = await fs.realpath(Bun.which(agentfs) ?? agentfs);
-	const repo = await fs.realpath(base);
-	await ownedDirectory(cache);
-	const key = await templateKey(executable, repo);
-	const template = path.join(cache, key);
-	const existing = await fs.lstat(template).catch((error: NodeJS.ErrnoException) => {
-		if (error.code !== "ENOENT") throw error;
-		return null;
-	});
-	if (!existing) {
-		const staging = await fs.mkdtemp(path.join(cache, ".initializing-"));
-		try {
-			await $`${executable} init run --base ${repo}`.cwd(staging).quiet();
-			if (key !== (await templateKey(executable, repo)))
-				throw new Error("AgentFS or repository changed during initialization");
-			const database = path.join(staging, ".agentfs");
-			await fs.chmod(database, 0o700);
-			for (const name of await fs.readdir(database)) await fs.chmod(path.join(database, name), 0o600);
-			// Publish only after the initializing process has exited, including its
-			// database sidecars. Concurrent creators can safely use the winner.
-			await fs.rename(database, template).catch((error: NodeJS.ErrnoException) => {
-				if (error.code !== "EEXIST" && error.code !== "ENOTEMPTY") throw error;
-			});
-		} finally {
-			await fs.rm(staging, { recursive: true, force: true });
-		}
-	}
-	const destination = path.join(tempDir, ".agentfs");
-	await copyTemplate(template, destination);
-	validateEmptyDatabase(path.join(destination, "run.db"), repo);
-	if (key !== (await templateKey(executable, repo)))
-		throw new Error("AgentFS or repository changed while preparing the transaction database");
-	return path.join(destination, "run.db");
-}

package/api.d.ts

@@ -1,15 +0,0 @@
-/** Types for programs executed by the code tool. Type-only: this does not install runtime globals. */
-import type { ShorthandGlobals } from "./prelude.ts";
-
-declare global {
-	const $: ShorthandGlobals["$"];
-	const edit: ShorthandGlobals["edit"];
-	const glob: ShorthandGlobals["glob"];
-	const grep: ShorthandGlobals["grep"];
-	const sg: ShorthandGlobals["sg"];
-	const grit: ShorthandGlobals["grit"];
-	const refactor: ShorthandGlobals["refactor"];
-}
-
-export type { RewriteResult } from "./prelude.ts";
-export type { ShorthandGlobals };