pi-shorthand 0.8.0 → 0.9.0

package/README.md

@@ -6,11 +6,16 @@ A [Pi](https://github.com/earendil-works/pi) tool for editing repositories with
 
 ## 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:
@@ -34,3 +39,7 @@ pi-shorthand gives Pi a programming environment instead of a patch format. This
 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.
 
 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`, with a `shorthand` command that runs a program from a file or stdin and prints the same result. See `shorthand --help`.

package/package.json

@@ -1,58 +1,36 @@
 {
 	"name": "pi-shorthand",
-	"version": "0.8.0",
+	"version": "0.9.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",
+	"homepage": "https://github.com/sebinsua/pi-shorthand/tree/main/packages/pi-shorthand#readme",
 	"bugs": "https://github.com/sebinsua/pi-shorthand/issues",
 	"license": "MIT",
 	"author": "Seb Insua",
 	"repository": {
 		"type": "git",
-		"url": "git+https://github.com/sebinsua/pi-shorthand.git"
+		"url": "git+https://github.com/sebinsua/pi-shorthand.git",
+		"directory": "packages/pi-shorthand"
 	},
 	"files": [
-		"*.c",
-		"*.ts",
+		"src",
 		"skills",
 		"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"
+		"prepack": "cp ../../README.md README.md"
 	},
 	"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.9.0"
 	},
 	"peerDependencies": {
 		"@earendil-works/pi-ai": "*",
@@ -74,9 +52,12 @@
 			"optional": true
 		}
 	},
+	"engines": {
+		"bun": ">=1.4"
+	},
 	"pi": {
 		"extensions": [
-			"./index.ts"
+			"./src/index.ts"
 		],
 		"skills": [
 			"./skills"

package/skills/shorthand/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: shorthand
-description: Edit repository files with Bun programs using plain text edits or structural matching. Covers renames, file and declaration moves, and call-site migrations; the advanced guide covers extracting code, moving syntax, GritQL and other languages.
+description: Edit repository files with Bun programs using plain text edits or structural matching. Covers renames, file and declaration moves, and call-site migrations; the advanced guide covers extracting code, moving syntax and rule objects.
 ---
 
 # Shorthand
@@ -113,6 +113,5 @@ detected project formatter. Counters and console summaries aren't required.
 
 This page covers renames, file and declaration moves, and call-site migrations. Read
 [advanced-refactors.md](advanced-refactors.md) only to extract code into a new function or file,
-insert, move or remove other statements, use GritQL or the native ast-grep API, or edit languages other
-than JS/TS. The bundled TypeScript 7 package has no legacy compiler API; use the supplied structural
-tools instead.
+insert, move or remove other statements, or use rule objects or the native ast-grep API. The bundled
+TypeScript 7 package has no legacy compiler API; use the supplied structural tools instead.

package/skills/shorthand/advanced-refactors.md

@@ -93,6 +93,8 @@ sg.find(
 	{ rule: { pattern: "console.log($$$A)", not: { inside: { kind: "function_declaration", stopBy: "end" } } } },
 	"src",
 );
+// constraints restrict what a capture may match
+sg.rewrite({ rule: { pattern: "$F($X)" }, constraints: { F: { regex: "^(oldApi|legacyApi)$" } } }, "newApi($X)", "src");
 ```
 
 `kind` names come from tree-sitter (`function_declaration`, `call_expression`, `import_statement`,
@@ -113,35 +115,6 @@ await Bun.write("src/app.ts", root.commitEdits(edits));
 The bundled TypeScript 7 package does not expose the legacy compiler API (`createSourceFile`,
 `ScriptTarget`); changing import syntax won't make it available.
 
-## GritQL and other languages
-
-Code goes in backticks. `$x` captures a node, `=>` rewrites, and `where` adds conditions.
-
-```ts
-grit("`oldApi($args)`", "src", { dryRun: true }); // find: [{ file, matches }]
-grit("`console.log($m)` => `logger.info($m)`", "src"); // rewrite in place
-grit("`$f($x)` where { $f <: `oldApi` }", "src", { dryRun: true }); // conditions
-grit("`print($x)` => `log($x)`", "src", { lang: "python" }); // other languages
-```
-
-It defaults to JavaScript/TypeScript. Other languages include python, go, rust, java, ruby, css,
-json and yaml.
-
-Paths accept files, directories, globs, `sg.file()` targets or mixed arrays.
-
-Worth knowing:
-
-- Each `grit` call takes about a second to start. That time does not count toward the program's
-  timeout.
-- A rewrite can drop a statement's trailing semicolon. Check the diff, or use `sg.rewrite` for
-  simple JS/TS rewrites.
-
-The bundled ast-grep CLI also supports other languages:
-
-```ts
-await $`ast-grep run -p 'print($A)' -r 'log($A)' -l python -U src`;
-```
-
 ## File discovery and commands
 
 ```ts
@@ -150,7 +123,7 @@ grep("oldApi(", "src"); // [{ file, line, text }]; accepts a RegExp too
 const files = await $`git ls-files`.text();
 ```
 
-`glob`, `grep`, `sg` and `grit` are synchronous. Bun's `$` needs `await`; interpolated values are
+`glob`, `grep` and `sg` are synchronous. Bun's `$` needs `await`; interpolated values are
 quoted as single arguments, and arrays become multiple arguments. These globals and bundled CLIs
 belong to `code`, not necessarily ordinary shell calls. `node:fs` and ordinary Bun APIs also work.
 
@@ -162,12 +135,12 @@ path is inaccessible on macOS. On both platforms, host paths outside the workspa
 Writes to `.git` are blocked.
 
 The default timeout is two seconds; request more for longer transformations. Time inside helpers
-(`edit`, `glob`, `grep`, `sg`, `grit`, `refactor`) does not count toward it, up to 60 extra seconds per run.
+(`edit`, `glob`, `grep`, `sg`, `refactor`) does not count toward it, up to 60 extra seconds per run.
 By default, rollback happens per file: files involved in failed or interrupted edits are discarded,
 while the others are retained, including after exceptions. Unattributed failures
 (such as failed checks) preserve completed edits and report the failure. A failed file loses all
-its edits from this run, even if the error is caught. Multi-file operations such as moves and a
-single Grit invocation share one outcome. Arbitrary shell failures cannot identify failed closed
+its edits from this run, even if the error is caught. Multi-file operations such as moves share
+one outcome. Arbitrary shell failures cannot identify failed closed
 files. Open writers are inspected before failure exits and timeout termination; inspection failures
 or crashes that bypass exit handling retain nothing. Cancellation still discards everything.
 Use `rollback: "all"` when the whole change must be atomic.

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,153 @@
+/**
+ * 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 * 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,
+	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.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.`;
+
+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
+	// 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: DESCRIPTION,
+		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",
+					},
+					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 };