@anton-kochev/pi-extensions 0.1.0

package/README.md

@@ -0,0 +1,41 @@
+# pi-extensions
+
+Pi extensions for personal use, installed as a single pi-package from this repository.
+
+## Install via pithos
+
+In your project's `.pithos`:
+
+```yaml
+pi:
+  extensions:
+    squiggle: "git:https://github.com/anton-kochev/pi-extensions.git#main"
+```
+
+Pithos's entrypoint passes this to `pi install`, which clones the repo, runs `npm install`, and registers the extensions declared in the root `pi.extensions` manifest.
+
+## Install directly with pi
+
+```bash
+pi install git:github.com/anton-kochev/pi-extensions
+```
+
+Pin to a tag for reproducibility:
+
+```bash
+pi install git:github.com/anton-kochev/pi-extensions@v0.1.0
+```
+
+## Extensions in this repo
+
+- [`squiggle/`](./squiggle) — quietly polish grammar and spelling in user prompts.
+
+## Local development
+
+From a checkout of this repo:
+
+```bash
+pi install -l ./squiggle
+```
+
+Each subdirectory has its own `package.json` so individual extensions remain installable in isolation.

package/package.json

@@ -0,0 +1,19 @@
+{
+  "name": "@anton-kochev/pi-extensions",
+  "version": "0.1.0",
+  "description": "Pi extensions.",
+  "keywords": ["pi-package"],
+  "license": "MIT",
+  "type": "module",
+  "files": ["squiggle", "README.md"],
+  "publishConfig": {
+    "access": "public"
+  },
+  "peerDependencies": {
+    "@earendil-works/pi-ai": "*",
+    "@earendil-works/pi-coding-agent": "*"
+  },
+  "pi": {
+    "extensions": ["./squiggle/extensions"]
+  }
+}

package/squiggle/README.md

@@ -0,0 +1,86 @@
+# squiggle
+
+Quietly polish grammar and spelling in your pi prompts.
+
+The extension intercepts user input, corrects spelling and grammar using a configured model, shows a colored diff, and submits the corrected prompt automatically without confirmation. Named after the red squiggle from your favorite spell-checker.
+
+## Install
+
+This extension ships as part of the [`pi-extensions`](https://github.com/anton-kochev/pi-extensions) repository. The simplest install path is via the root pi-package — see the [repo README](../README.md).
+
+For local development from a checkout of `pi-extensions`:
+
+```bash
+pi install ./squiggle
+```
+
+Project-local install:
+
+```bash
+pi install ./squiggle -l
+```
+
+Temporary test run:
+
+```bash
+pi -e ./squiggle
+```
+
+## Pithos `.pithos` config
+
+```yaml
+pi:
+  extensions:
+    squiggle: "git:https://github.com/anton-kochev/pi-extensions.git#main"
+```
+
+Pin to a tag for reproducibility:
+
+```yaml
+pi:
+  extensions:
+    squiggle: "git:https://github.com/anton-kochev/pi-extensions.git#v0.1.0"
+```
+
+## Configuration
+
+Create `.pi/squiggle.json` in your project:
+
+```json
+{
+  "mode": "on",
+  "model": "openai-codex/gpt-5.4-mini",
+  "maxInputChars": 500
+}
+```
+
+Options:
+
+- `mode`: `"on"` or `"off"`
+- `model`: pi model spec in `provider/model` format
+- `maxInputChars`: maximum input length to send to the correction model
+
+Environment variables override the config file:
+
+```bash
+SQUIGGLE_MODE=off pi
+SQUIGGLE_MODEL=openai-codex/gpt-5.4-mini pi
+SQUIGGLE_MAX_CHARS=1000 pi
+```
+
+## Status
+
+Inside pi:
+
+```text
+/squiggle-status
+```
+
+## Notes
+
+This package imports pi runtime packages as peer dependencies:
+
+- `@earendil-works/pi-ai`
+- `@earendil-works/pi-coding-agent`
+
+Do not bundle those dependencies; pi provides them at runtime.

package/squiggle/extensions/squiggle.ts

@@ -0,0 +1,209 @@
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { complete, type UserMessage } from "@earendil-works/pi-ai";
+import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
+
+export default function squiggle(pi: ExtensionAPI) {
+	pi.registerCommand("squiggle-status", {
+		description: "Show whether squiggle is loaded",
+		handler: async (_args, ctx) => {
+			const config = loadConfig(ctx.cwd);
+			const model = selectCorrectionModel(ctx, config);
+			ctx.ui.notify(`squiggle is loaded (${config.mode}, ${formatModel(model)}).`, "info");
+		},
+	});
+
+	pi.on("input", async (event, ctx) => {
+		if (event.source === "extension") return { action: "continue" };
+
+		const config = loadConfig(ctx.cwd);
+		if (config.mode === "off") return { action: "continue" };
+		if (!event.text.trim()) return { action: "continue" };
+
+		const corrected = await correctWithModel(event.text, ctx, config);
+		if (!corrected || corrected === event.text) return { action: "continue" };
+
+		if (ctx.hasUI) ctx.ui.notify(formatColoredDiff(event.text, corrected), "info");
+
+		// In interactive mode, `transform` changes what the agent receives, but the
+		// already-submitted prompt may still be rendered as originally typed. To make
+		// the visible user message corrected too, swallow the original input and
+		// resubmit the corrected text as an extension-originated user message. The
+		// source guard above prevents a correction loop.
+		if (event.source === "interactive") {
+			pi.sendUserMessage(corrected);
+			return { action: "handled" };
+		}
+
+		return { action: "transform", text: corrected };
+	});
+}
+
+const CORRECTION_PROMPT = `You are a conservative grammar and spelling corrector for user prompts sent to a coding assistant.
+
+Task:
+- Correct spelling, grammar, capitalization, and punctuation.
+- Preserve the user's meaning, tone, language, and intent.
+- Do not answer the prompt.
+- Do not add explanations, quotes, prefixes, markdown fences, or alternatives.
+- If the input is already acceptable, return it unchanged.
+- Return only the corrected prompt text.`;
+
+const DEFAULT_CORRECTION_MODEL = "openai-codex/gpt-5.4-mini";
+const DEFAULT_MAX_LLM_INPUT_CHARS = 500;
+
+type SquiggleConfig = {
+	mode: "on" | "off";
+	model: string;
+	maxInputChars: number;
+};
+
+async function correctWithModel(input: string, ctx: ExtensionContext, config: SquiggleConfig): Promise<string | null> {
+	const model = selectCorrectionModel(ctx, config);
+	if (!model) return null;
+	if (input.length > config.maxInputChars) return null;
+
+	try {
+		const auth = await ctx.modelRegistry.getApiKeyAndHeaders(model);
+		if (!auth.ok || !auth.apiKey) return null;
+
+		const userMessage: UserMessage = {
+			role: "user",
+			content: [{ type: "text", text: input }],
+			timestamp: Date.now(),
+		};
+
+		const response = await complete(
+			model,
+			{ systemPrompt: CORRECTION_PROMPT, messages: [userMessage] },
+			{ apiKey: auth.apiKey, headers: auth.headers },
+		);
+
+		if (response.stopReason === "aborted") return null;
+
+		return response.content
+			.filter((c): c is { type: "text"; text: string } => c.type === "text")
+			.map((c) => c.text)
+			.join("\n")
+			.trim();
+	} catch {
+		return null;
+	}
+}
+
+function loadConfig(cwd: string): SquiggleConfig {
+	const fileConfig = readConfigFile(cwd);
+	return {
+		mode: normalizeMode(process.env.SQUIGGLE_MODE ?? fileConfig.mode) ?? "on",
+		model: process.env.SQUIGGLE_MODEL ?? fileConfig.model ?? DEFAULT_CORRECTION_MODEL,
+		maxInputChars: normalizePositiveInt(process.env.SQUIGGLE_MAX_CHARS ?? fileConfig.maxInputChars) ?? DEFAULT_MAX_LLM_INPUT_CHARS,
+	};
+}
+
+function readConfigFile(cwd: string): Partial<SquiggleConfig> {
+	const path = join(cwd, ".pi", "squiggle.json");
+	if (!existsSync(path)) return {};
+	try {
+		const parsed = JSON.parse(readFileSync(path, "utf8")) as Record<string, unknown>;
+		return {
+			mode: typeof parsed.mode === "string" ? normalizeMode(parsed.mode) : undefined,
+			model: typeof parsed.model === "string" ? parsed.model : undefined,
+			maxInputChars: normalizePositiveInt(parsed.maxInputChars),
+		};
+	} catch {
+		return {};
+	}
+}
+
+function normalizeMode(value: unknown): SquiggleConfig["mode"] | undefined {
+	return value === "on" || value === "off" ? value : undefined;
+}
+
+function normalizePositiveInt(value: unknown): number | undefined {
+	const parsed = typeof value === "number" ? value : typeof value === "string" ? Number.parseInt(value, 10) : Number.NaN;
+	return Number.isInteger(parsed) && parsed > 0 ? parsed : undefined;
+}
+
+function selectCorrectionModel(ctx: ExtensionContext, config: SquiggleConfig) {
+	const configured = parseModelSpec(config.model);
+	if (configured) {
+		const model = ctx.modelRegistry.find(configured.provider, configured.model);
+		if (model) return model;
+	}
+	return ctx.model;
+}
+
+function parseModelSpec(spec: string): { provider: string; model: string } | null {
+	const slash = spec.indexOf("/");
+	if (slash <= 0 || slash === spec.length - 1) return null;
+	return { provider: spec.slice(0, slash), model: spec.slice(slash + 1) };
+}
+
+function formatModel(model: ReturnType<typeof selectCorrectionModel>): string {
+	return model ? `${model.provider}/${model.id}` : "no model";
+}
+
+type DiffOp = {
+	type: "same" | "add" | "remove";
+	text: string;
+};
+
+function formatColoredDiff(before: string, after: string): string {
+	const dim = "\x1b[90;3m";
+	const same = "\x1b[90;3m";
+	const added = "\x1b[32;3m";
+	const removed = "\x1b[31;3m";
+	const reset = "\x1b[0m";
+
+	const rendered = diffChars(before.trim(), after.trim())
+		.map((op) => {
+			if (op.type === "add") return `${added}${op.text}${reset}`;
+			if (op.type === "remove") return `${removed}${op.text}${reset}`;
+			return `${same}${op.text}${reset}`;
+		})
+		.join("");
+
+	return `${dim}squiggle:${reset}\n${rendered}`;
+}
+
+function diffChars(before: string, after: string): DiffOp[] {
+	const beforeChars = Array.from(before);
+	const afterChars = Array.from(after);
+	const rows = beforeChars.length + 1;
+	const cols = afterChars.length + 1;
+	const dp: number[][] = Array.from({ length: rows }, () => Array(cols).fill(0));
+
+	for (let i = beforeChars.length - 1; i >= 0; i--) {
+		for (let j = afterChars.length - 1; j >= 0; j--) {
+			dp[i]![j] = beforeChars[i] === afterChars[j] ? dp[i + 1]![j + 1]! + 1 : Math.max(dp[i + 1]![j]!, dp[i]![j + 1]!);
+		}
+	}
+
+	const ops: DiffOp[] = [];
+	let i = 0;
+	let j = 0;
+	while (i < beforeChars.length || j < afterChars.length) {
+		if (i < beforeChars.length && j < afterChars.length && beforeChars[i] === afterChars[j]) {
+			pushDiffOp(ops, "same", afterChars[j]!);
+			i++;
+			j++;
+		} else if (j < afterChars.length && (i === beforeChars.length || dp[i]![j + 1]! > dp[i + 1]![j]!)) {
+			pushDiffOp(ops, "add", afterChars[j]!);
+			j++;
+		} else if (i < beforeChars.length) {
+			pushDiffOp(ops, "remove", beforeChars[i]!);
+			i++;
+		}
+	}
+
+	return ops;
+}
+
+function pushDiffOp(ops: DiffOp[], type: DiffOp["type"], text: string) {
+	const last = ops.at(-1);
+	if (last?.type === type) {
+		last.text += text;
+		return;
+	}
+	ops.push({ type, text });
+}

package/squiggle/index.ts

@@ -0,0 +1 @@
+export { default } from "./extensions/squiggle.ts";

package/squiggle/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "squiggle",
+  "version": "0.1.0",
+  "description": "Quietly polish grammar and spelling in your pi prompts.",
+  "keywords": [
+    "pi-package",
+    "pi-extension",
+    "grammar",
+    "writing"
+  ],
+  "license": "MIT",
+  "type": "module",
+  "peerDependencies": {
+    "@earendil-works/pi-ai": "*",
+    "@earendil-works/pi-coding-agent": "*"
+  },
+  "pi": {
+    "extensions": [
+      "./extensions"
+    ]
+  },
+  "files": [
+    "index.ts",
+    "extensions",
+    "README.md"
+  ]
+}