opencode-fmt 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Ritesh Kumar Pal
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,58 @@
+# OpenCode FMT Plugin
+
+A unified, single-pass text optimization plugin for OpenCode that sanitizes emojis and formats markdown tables deterministically.
+
+## Features
+
+1. **Deterministic Emoji Sanitizer:** Surgically removes emojis from AI outputs without altering the surrounding whitespace or layout.
+2. **Isolated Table Aligner:** Formats Markdown tables by calculating maximum column widths and applying deterministic padding, ensuring visual correctness.
+3. **Zero-Dependency Engine:** Processes the AI output in a single pass ($O(n)$ latency) without generating an AST or relying on third-party libraries like Prettier or Remark.
+4. **Flat Configuration:** Simple, flat boolean configuration file with nested-object crash safety.
+
+## Installation
+
+This is an OpenCode-native TypeScript plugin. OpenCode executes it via Bun. 
+
+There are no external parsing dependencies required.
+
+```json
+// package.json (dev setup)
+{
+  "name": "opencode-postgen-pipeline",
+  "private": true,
+  "type": "module",
+  "packageManager": "bun@1.3.11",
+  "devDependencies": {
+    "typescript": "5.9.3",
+    "bun-types": "latest"
+  }
+}
+```
+
+## Configuration
+
+Create a `config.json` inside your plugin root directory. The plugin only accepts a flat structure.
+
+```json
+{
+  "stripEmojis": true,
+  "alignTables": true,
+  "logMetrics": false
+}
+```
+
+## Performance
+
+To prove the core value proposition of an $O(n)$ single pass, this plugin includes latency telemetry.
+
+**Benchmark:** 
+Processing a highly-mixed payload of 10,000 words containing text, emojis, and tables:
+* **Result:** `~4.0ms` (Target limit: `< 50ms`)
+
+## Architectural Constraints (Strict)
+
+This plugin is governed by strict, locked technical rules to preserve its performance:
+1. **Single-pass only:** No second iterations over the buffer.
+2. **Zero runtime dependencies.**
+3. **Flat config:** No nested structures or custom AST rules.
+4. **Diff Stability:** Non-target text (pure paragraphs) is preserved byte-for-byte in the output to avoid noisy Git diffs.

package/debug.ts

@@ -0,0 +1,16 @@
+import { alignTable } from "./src/table-aligner";
+
+const inputCenter = ["| Item | Amount |", "|:---:|----:|", "| a | long |"];
+console.log("Center test: ");
+const resultCenter = alignTable(inputCenter);
+console.log(resultCenter.join("\n"));
+
+const inputRight = ["| Name | Score |", "|---:|-----:|", "| Alice | 100 |"];
+console.log("\nRight test: ");
+const resultRight = alignTable(inputRight);
+console.log(resultRight.join("\n"));
+
+const inputMixed = ["| Left | Center | Right |", "| :--- | :---: | ---: |", "| l | center | rvalue |"];
+console.log("\nMixed test: ");
+const resultMixed = alignTable(inputMixed);
+console.log(resultMixed.join("\n"));

package/package.json

@@ -0,0 +1,26 @@
+{
+	"name": "opencode-fmt",
+	"version": "0.1.0",
+	"type": "module",
+	"main": "dist/index.js",
+	"exports": {
+		".": "./dist/index.js"
+	},
+	"private": false,
+	"packageManager": "bun@1.3.11",
+	"scripts": {
+		"dev": "bun run src/index.ts",
+		"build": "bun build src/index.ts --outfile=dist/index.js --target=node --format=esm --external=@opencode-ai/plugin",
+		"test": "bun test",
+		"test:coverage": "bun test --coverage"
+	},
+	"devDependencies": {
+		"@opencode-ai/plugin": "^1.2.27",
+		"@types/bun": "^1.3.11",
+		"@types/node": "^25.5.0",
+		"typescript": "5.9.3"
+	},
+	"peerDependencies": {
+		"typescript": "^5"
+	}
+}

package/src/config.ts

@@ -0,0 +1,65 @@
+import fs from "node:fs";
+import path from "node:path";
+
+export interface PluginConfig {
+	stripEmojis: boolean;
+	alignTables: boolean;
+	logging: boolean;
+}
+
+export const DEFAULT_CONFIG: PluginConfig = {
+	stripEmojis: true,
+	alignTables: true,
+	logging: false,
+};
+
+export function loadConfig(pluginDir: string): PluginConfig {
+	const configPath = path.join(pluginDir, "config.json");
+
+	if (!fs.existsSync(configPath)) {
+		throw new Error(
+			`[opencode-fmt] Configuration file "config.json" is missing. Please create it in the project root.`,
+		);
+	}
+
+	let rawConfig: Record<string, unknown> = {};
+	try {
+		const fileContent = fs.readFileSync(configPath, "utf-8");
+		const parsedConfig = JSON.parse(fileContent);
+		if (typeof parsedConfig === "object" && parsedConfig !== null) {
+			rawConfig = parsedConfig as Record<string, unknown>;
+		} else {
+			throw new Error("Config file content is not a valid JSON object.");
+		}
+	} catch (err) {
+		throw new Error(
+			`[opencode-fmt] Failed to parse config.json: ${err instanceof Error ? err.message : String(err)}`,
+		);
+	}
+
+	const finalConfig: PluginConfig = { ...DEFAULT_CONFIG };
+
+	for (const key of Object.keys(DEFAULT_CONFIG) as Array<keyof PluginConfig>) {
+		if (Object.hasOwn(rawConfig, key)) {
+			const value = rawConfig[key];
+			if (typeof value === typeof DEFAULT_CONFIG[key]) {
+				(finalConfig[key] as unknown) = value;
+			} else {
+				throw new Error(
+					`[opencode-fmt] Config Error: Invalid type for "${key}". Expected ${typeof DEFAULT_CONFIG[key]}, got ${typeof value}.`,
+				);
+			}
+		}
+	}
+
+	for (const [key, value] of Object.entries(rawConfig)) {
+		if (typeof value === "object" && value !== null && !Array.isArray(value)) {
+			throw new Error(
+				`[opencode-fmt] Config Error: Nested object at "${key}". Only flat keys allowed.`,
+			);
+		}
+		(finalConfig as unknown as Record<string, unknown>)[key] = value;
+	}
+
+	return finalConfig as PluginConfig;
+}

package/src/emoji-sanitizer.ts

@@ -0,0 +1,7 @@
+export const EMOJI_REGEX =
+	/\p{Emoji_Presentation}|\p{Extended_Pictographic}|\u200d|\ufe0f|\u20e3|\u20e0|\p{RI}/gu;
+
+export function sanitizeEmojis(text: string): string {
+	if (!text) return text;
+	return text.replace(EMOJI_REGEX, "");
+}

package/src/engine.ts

@@ -0,0 +1,52 @@
+import type { PluginConfig } from "./config";
+import { sanitizeEmojis } from "./emoji-sanitizer";
+import { alignTable } from "./table-aligner";
+
+export function runPipeline(text: string, config: PluginConfig): string {
+	if (!text) return text;
+
+	const lines = text.split("\n");
+	const resultLines: string[] = [];
+
+	let isInTable = false;
+	let tableBuffer: string[] = [];
+
+	const flushTable = () => {
+		if (tableBuffer.length > 0) {
+			const output = config.alignTables ? alignTable(tableBuffer) : tableBuffer;
+			resultLines.push(...output);
+			tableBuffer = [];
+		}
+	};
+
+	for (const line of lines) {
+		let processedLine = line;
+
+		if (config.stripEmojis) {
+			processedLine = sanitizeEmojis(processedLine);
+		}
+
+		const isTableRow = processedLine.trim().startsWith("|");
+
+		if (isTableRow) {
+			isInTable = true;
+			tableBuffer.push(processedLine);
+		} else {
+			if (isInTable) {
+				flushTable();
+				isInTable = false;
+			}
+			resultLines.push(processedLine);
+		}
+	}
+
+	flushTable();
+
+	const result = resultLines.join("\n");
+
+	if (text.trim().length > 0 && result.trim().length === 0) {
+		return "[Only emojis received and redacted by opencode-fmt]";
+	}
+
+	return result;
+}

package/src/index.ts

@@ -0,0 +1,59 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import type { Hooks, Plugin, PluginInput } from "@opencode-ai/plugin";
+import { loadConfig, type PluginConfig } from "./config";
+import { runPipeline } from "./engine";
+import { measureExecution } from "./metrics";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const PLUGIN_DIR = path.join(__dirname, "..");
+
+export type { PluginInput };
+
+export const OpenCodeFmt: Plugin = async (_input: PluginInput) => {
+	const logPath = path.join(PLUGIN_DIR, "opencode-fmt.log");
+
+	let config: PluginConfig;
+	try {
+		config = loadConfig(PLUGIN_DIR);
+		if (config.logging) {
+			const bootMsg = `[opencode-fmt] ${new Date().toLocaleString()} | Plugin Started | Config: ${JSON.stringify(config)}\n`;
+			await fs.appendFile(logPath, bootMsg).catch(() => {});
+		}
+	} catch (err) {
+		const fatalMsg = `[opencode-fmt] ${new Date().toLocaleString()} | FATAL STARTUP ERROR: ${err instanceof Error ? err.message : String(err)}\n`;
+		await fs.appendFile(logPath, fatalMsg).catch(() => {});
+		throw err;
+	}
+
+	return {
+		"experimental.text.complete": async (_hookInput, hookOutput) => {
+			const rawText = hookOutput.text || "";
+
+			const { result: processedText, duration } = measureExecution(() =>
+				runPipeline(rawText, config),
+			);
+
+			hookOutput.text = processedText;
+
+			if (config.logging) {
+				try {
+					const timestamp = new Date().toLocaleString();
+					let logMsg = "";
+
+					if (rawText === processedText) {
+						logMsg = `[opencode-fmt] ${timestamp} | Duration: ${duration}ms | Hook triggered | Response: ${JSON.stringify(rawText)}\n`;
+					} else {
+						logMsg = `[opencode-fmt] ${timestamp} | Duration: ${duration}ms | Hook triggered | Raw: ${JSON.stringify(rawText)} | Cleaned: ${JSON.stringify(processedText)}\n`;
+					}
+
+					fs.appendFile(logPath, logMsg).catch(() => {});
+				} catch (_) {}
+			}
+		},
+	} as Hooks;
+};
+
+export default OpenCodeFmt;

package/src/metrics.ts

@@ -0,0 +1,9 @@
+export function measureExecution<T>(fn: () => T): {
+	result: T;
+	duration: string;
+} {
+	const start = performance.now();
+	const result = fn();
+	const duration = (performance.now() - start).toFixed(2);
+	return { result, duration };
+}

package/src/passes/echo.ts

@@ -0,0 +1,11 @@
+import type { Config, Pass } from "../config.js";
+
+export const echoPass: Pass = {
+  name: "echo",
+  enabled: () => true,
+  transform: (text: string, _cfg: Config) => {
+    process.stderr.write(`opencode-fmt: echo — received ${text.length} chars\n`);
+    process.stderr.write(`opencode-fmt: echo — received text:\n${text}\n---\n`);
+    return text;
+  }
+};

package/src/pipeline.ts

@@ -0,0 +1,21 @@
+import type { Config, Pass } from "./config.js";
+import { echoPass } from "./passes/echo.js";
+
+const passes: Pass[] = [
+  echoPass,
+];
+
+export function runPipeline(text: string, cfg: Config): string {
+  if (!text || passes.length === 0) return text;
+
+  let result = text;
+
+  for (let i = 0, len = passes.length; i < len; i++) {
+    const pipe = passes[i];
+    if (pipe.enabled(cfg)) {
+      result = pipe.transform(result, cfg);
+    }
+  }
+
+  return result;
+}

package/src/table-aligner.ts

@@ -0,0 +1,86 @@
+type Alignment = "default" | "left" | "center" | "right";
+
+function parseAlignment(cell: string): Alignment {
+	const trimmed = cell.trim();
+	const leftColon = trimmed.startsWith(":");
+	const rightColon = trimmed.endsWith(":");
+
+	if (leftColon && rightColon) return "center";
+	if (rightColon) return "right";
+	if (leftColon) return "left";
+	return "default";
+}
+
+function formatSeparator(width: number, align: Alignment): string {
+	const w = Math.max(3, width);
+	if (align === "center") return ":" + "-".repeat(w - 2) + ":";
+	if (align === "right") return "-".repeat(w - 1) + ":";
+	if (align === "left") return ":" + "-".repeat(w - 1);
+	return "-".repeat(w);
+}
+
+function padCell(cell: string, width: number, align: Alignment): string {
+	const padding = Math.max(0, width - cell.length);
+
+	if (align === "center") {
+		const leftPad = Math.floor(padding / 2);
+		const rightPad = padding - leftPad;
+		return " ".repeat(leftPad) + cell + " ".repeat(rightPad);
+	}
+	if (align === "right") {
+		return " ".repeat(padding) + cell;
+	}
+	return cell + " ".repeat(padding);
+}
+
+export function alignTable(rows: string[]): string[] {
+	const rowCount = rows.length;
+	if (rowCount === 0) return rows;
+
+	const tableData = new Array(rowCount);
+	const colWidths: number[] = [];
+	const colAlignments: Alignment[] = [];
+
+	for (let i = 0; i < rowCount; i++) {
+		const row = rows[i];
+		let trimmedRow = row.trim();
+		if (trimmedRow.startsWith("|")) trimmedRow = trimmedRow.slice(1);
+		if (trimmedRow.endsWith("|")) trimmedRow = trimmedRow.slice(0, -1);
+
+		const cells = trimmedRow.split("|").map((c) => c.trim());
+		const isSeparator = cells.length > 0 && cells.every((c) => /^\s*:?-+:?\s*$/.test(c));
+
+		tableData[i] = { cells, isSeparator };
+
+		if (isSeparator) {
+			for (let j = 0; j < cells.length; j++) {
+				colAlignments[j] = parseAlignment(cells[j]);
+			}
+		} else {
+			for (let j = 0; j < cells.length; j++) {
+				const cellLength = cells[j].length;
+				if (colWidths[j] === undefined || cellLength > colWidths[j]) {
+					colWidths[j] = cellLength;
+				}
+			}
+		}
+	}
+
+	const colCount = colWidths.length;
+
+	return tableData.map((row) => {
+		const paddedCells = new Array(colCount);
+		for (let i = 0; i < colCount; i++) {
+			const cell = row.cells[i] || "";
+			const width = colWidths[i] || 0;
+			const align = colAlignments[i] || "default";
+
+			if (row.isSeparator) {
+				paddedCells[i] = formatSeparator(width, align);
+			} else {
+				paddedCells[i] = padCell(cell, width, align);
+			}
+		}
+		return `| ${paddedCells.join(" | ")} |`;
+	});
+}

package/tests/aligner.test.ts

@@ -0,0 +1,100 @@
+import { describe, expect, test } from "bun:test";
+import { runPipeline } from "../src/engine";
+import { alignTable } from "../src/table-aligner";
+
+describe("Table Aligner", () => {
+	test("aligns basic table", () => {
+		const input = ["| Header 1 | H2 |", "|---|---|", "| Val | Long Value |"];
+		const expected = [
+			"| Header 1 | H2         |",
+			"| -------- | ---------- |",
+			"| Val      | Long Value |",
+		];
+		expect(alignTable(input)).toEqual(expected);
+	});
+
+	test("handles misaligned input pipes", () => {
+		const input = ["|   Key   | Value|", "|---|---|", "|a|b|"];
+		const expected = ["| Key | Value |", "| --- | ----- |", "| a   | b     |"];
+		expect(alignTable(input)).toEqual(expected);
+	});
+
+	test("fills missing columns in short rows", () => {
+		const input = ["| H1 | H2 |", "|---|---|", "| Single |"];
+		const result = alignTable(input);
+		expect(result[0]).toBe("| H1     | H2 |");
+		expect(result[1]).toBe("| ------ | --- |");
+		expect(result[2]).toBe("| Single |    |");
+	});
+
+	test("handles empty input", () => {
+		expect(alignTable([])).toEqual([]);
+	});
+
+	test("preserves center alignment", () => {
+		const input = ["| Item | Amount |", "|:---:|----:|", "| a | long |"];
+		const result = alignTable(input);
+		expect(result[0]).toBe("| Item | Amount |");
+		expect(result[1]).toBe("| :----: | ------: |");
+		expect(result[2]).toBe("|  a    |   long |");
+	});
+
+	test("preserves right alignment", () => {
+		const input = ["| Name | Score |", "|---:|-----:|", "| Alice | 100 |"];
+		const result = alignTable(input);
+		expect(result[0]).toBe("| Name | Score |");
+		expect(result[1]).toBe("| -----: | -----: |");
+		expect(result[2]).toBe("| Alice |   100 |");
+	});
+
+	test("preserves mixed alignment", () => {
+		const input = ["| Left | Center | Right |", "| :--- | :---: | ---: |", "| l | center | rvalue |"];
+		const result = alignTable(input);
+		expect(result[1]).toBe("| :--- | :-----: | ------: |");
+		expect(result[2]).toBe("| l   |  center | rvalue |");
+	});
+});
+
+describe("Diff Stability", () => {
+	const cfg = { stripEmojis: false, alignTables: true, logMetrics: false };
+
+	test("plain text with no tables passes through byte-identical", () => {
+		const input = "This is plain text.\nNo tables here.\nJust three lines.";
+		expect(runPipeline(input, cfg)).toBe(input);
+	});
+
+	test("only table lines change in a mixed document", () => {
+		const before = "Intro line — unchanged.";
+		const table = "| A | B |\n|---|---|\n| 1 | 2 |";
+		const after = "Outro line — unchanged.";
+		const input = `${before}\n${table}\n${after}`;
+
+		const result = runPipeline(input, cfg);
+		const lines = result.split("\n");
+
+		expect(lines[0]).toBe(before);
+		expect(lines[lines.length - 1]).toBe(after);
+
+		const rawTableLines = table.split("\n");
+		const resultTableLines = lines.slice(1, lines.length - 1);
+		expect(resultTableLines).not.toEqual(rawTableLines);
+
+		expect(resultTableLines[0]).toContain("A");
+		expect(resultTableLines[0]).toContain("B");
+	});
+
+	test("multiple non-table blocks between tables are untouched", () => {
+		const header = "# Title";
+		const para = "Some paragraph text here.";
+		const table = "| X | Y |\n|---|---|\n| a | b |";
+		const footer = "Footer text.";
+		const input = `${header}\n${para}\n${table}\n${footer}`;
+
+		const result = runPipeline(input, cfg);
+		const lines = result.split("\n");
+
+		expect(lines[0]).toBe(header);
+		expect(lines[1]).toBe(para);
+		expect(lines[lines.length - 1]).toBe(footer);
+	});
+});

package/tests/benchmarks.test.ts

@@ -0,0 +1,32 @@
+import { describe, expect, test } from "bun:test";
+import { DEFAULT_CONFIG } from "../src/config";
+import { runPipeline } from "../src/engine";
+
+describe("Performance Benchmarks (O(n) Constraint)", () => {
+	test("processes 10,000 mixed words in under 50ms", () => {
+		const paragraph =
+			"This is a standard paragraph containing some words. Here is an emoji 🚀 to make things interesting. Let's add some more text to bulk this out so we can truly stress test the single-pass nature of the traverse. We also have female pilots 👩‍✈️ and some flags 🇺🇸.\n";
+		const tableBlock =
+			"\n| Id | Name | Role |\n|---|---|\n| 1 | Alice 🦸‍♀️ | Admin |\n| 2 | Bob (No emoji) | User |\n| 3 | Charlie 👨‍💻 | Mod |\n";
+
+		let payload = "";
+		for (let i = 0; i < 200; i++) {
+			payload += paragraph;
+			if (i % 5 === 0) payload += tableBlock;
+		}
+
+		const wordCount = payload.split(/\s+/).length;
+		expect(wordCount).toBeGreaterThanOrEqual(10000);
+
+		const start = performance.now();
+		const result = runPipeline(payload, DEFAULT_CONFIG);
+		const durationMs = performance.now() - start;
+
+		console.log(
+			`[Benchmark] 10,000 words processed in ${durationMs.toFixed(2)}ms`,
+		);
+
+		expect(durationMs).toBeLessThan(50);
+		expect(result.includes("🚀")).toBe(false);
+	});
+});

package/tests/config.test.ts

@@ -0,0 +1,77 @@
+import {
+	afterEach,
+	beforeEach,
+	describe,
+	expect,
+	mock,
+	spyOn,
+	test,
+} from "bun:test";
+import fs from "node:fs";
+import path from "node:path";
+import { DEFAULT_CONFIG, loadConfig } from "../src/config";
+
+describe("Config Loader", () => {
+	const dir = "/fake/dir";
+	const _configPath = path.join(dir, "config.json");
+
+	beforeEach(() => {
+		spyOn(fs, "existsSync");
+		spyOn(fs, "readFileSync");
+	});
+
+	afterEach(() => {
+		mock.restore();
+	});
+
+	test("throws error if config.json is missing", () => {
+		spyOn(fs, "existsSync").mockReturnValue(false);
+		expect(() => loadConfig(dir)).toThrow(
+			/Configuration file "config.json" is missing/,
+		);
+	});
+
+	test("throws error if config.json is invalid JSON", () => {
+		spyOn(fs, "existsSync").mockReturnValue(true);
+		spyOn(fs, "readFileSync").mockReturnValue("{ bad json ]");
+		expect(() => loadConfig(dir)).toThrow(/Failed to parse config.json/);
+	});
+
+	test("loads config and merges with defaults", () => {
+		spyOn(fs, "existsSync").mockReturnValue(true);
+		spyOn(fs, "readFileSync").mockReturnValue(
+			JSON.stringify({ logging: true }),
+		);
+
+		const config = loadConfig(dir);
+
+		expect(config.logging).toBe(true);
+		expect(config.stripEmojis).toBe(DEFAULT_CONFIG.stripEmojis);
+		expect(config.alignTables).toBe(DEFAULT_CONFIG.alignTables);
+	});
+
+	test("throws error if config contains nested objects", () => {
+		spyOn(fs, "existsSync").mockReturnValue(true);
+		spyOn(fs, "readFileSync").mockReturnValue(
+			JSON.stringify({
+				stripEmojis: true,
+				nested: { deeply: true },
+			}),
+		);
+
+		expect(() => loadConfig(dir)).toThrow(/Nested object at "nested"/);
+	});
+
+	test("allows arrays in config (e.g. for future list features)", () => {
+		spyOn(fs, "existsSync").mockReturnValue(true);
+		spyOn(fs, "readFileSync").mockReturnValue(
+			JSON.stringify({
+				stripEmojis: true,
+				ignoredPaths: ["node_modules"],
+			}),
+		);
+
+		const config = loadConfig(dir) as Record<string, unknown>;
+		expect(config.ignoredPaths).toEqual(["node_modules"]);
+	});
+});

package/tests/engine.test.ts

@@ -0,0 +1,136 @@
+import { describe, expect, test } from "bun:test";
+import { runPipeline } from "../src/engine";
+
+const cfg = { stripEmojis: true, alignTables: true, logMetrics: false };
+const cfgOff = { stripEmojis: false, alignTables: false, logMetrics: false };
+
+describe("Emoji Sanitizer", () => {
+	test("strips a single emoji", () => {
+		expect(runPipeline("Hello 👋", cfg)).toBe("Hello ");
+	});
+
+	test("strips multiple emojis in a single pass", () => {
+		expect(runPipeline("🚀 Launch 🎉 Done", cfg)).toBe(" Launch  Done");
+	});
+
+	test("leaves plain text untouched", () => {
+		expect(runPipeline("No emojis here", cfg)).toBe("No emojis here");
+	});
+
+	test("empty string stays empty", () => {
+		expect(runPipeline("", cfg)).toBe("");
+	});
+
+	test("strips emojis at start and end of string", () => {
+		expect(runPipeline("🔥 hot take 🔥", cfg)).toBe(" hot take ");
+	});
+
+	test("returns redaction placeholder for emoji-only string", () => {
+		expect(runPipeline("😀🎉🚀", cfg)).toBe(
+			"[Only emojis received and redacted by opencode-fmt]",
+		);
+	});
+
+	test("returns redaction placeholder for emoji-only string with spaces", () => {
+		expect(runPipeline("  🚀  ", cfg)).toBe(
+			"[Only emojis received and redacted by opencode-fmt]",
+		);
+	});
+
+	test("preserves numbers and punctuation around emojis", () => {
+		expect(runPipeline("Step 1: 📋 check", cfg)).toBe("Step 1:  check");
+	});
+
+	test("preserves newlines and multiline content", () => {
+		expect(runPipeline("Line 1 🌍\nLine 2 🌏", cfg)).toBe("Line 1 \nLine 2 ");
+	});
+
+	test("strips skin-tone modifier sequences", () => {
+		expect(runPipeline("Hi 👋🏾 there", cfg)).toBe("Hi  there");
+	});
+
+	test("strips ZWJ family emoji sequences", () => {
+		expect(runPipeline("Family: 👨‍👩‍👧‍👦", cfg)).toBe("Family: ");
+	});
+
+	test("strips Unicode flag emojis", () => {
+		expect(runPipeline("🇮🇳 India", cfg)).toBe(" India");
+	});
+
+	test("strips Keycap sequence emojis like 1️⃣", () => {
+		expect(runPipeline("Count: 1️⃣ 2️⃣", cfg)).toBe("Count: 1 2");
+	});
+
+	test("strips dingbat emojis (Supplemental Symbols)", () => {
+		expect(runPipeline("Status: ✅ OK ❌ Fail", cfg)).toBe("Status:  OK  Fail");
+	});
+
+	test("strips extended pictographic symbols like 🤖 and 🦾", () => {
+		expect(runPipeline("AI 🤖 is 🦾 strong", cfg)).toBe("AI  is  strong");
+	});
+
+	test("strips emojis from markdown headings", () => {
+		expect(runPipeline("# Hello 👋 World", cfg)).toBe("# Hello  World");
+		expect(runPipeline("### Feature 🚀", cfg)).toBe("### Feature ");
+	});
+
+	test("strips emojis from markdown bold and italic text", () => {
+		expect(runPipeline("**Bold 💥 text** and *Italic 📝*", cfg)).toBe(
+			"**Bold  text** and *Italic *",
+		);
+	});
+
+	test("strips emojis from markdown lists (unordered and ordered)", () => {
+		expect(runPipeline("- Item 1 🍎\n- Item 2 🍌", cfg)).toBe(
+			"- Item 1 \n- Item 2 ",
+		);
+		expect(runPipeline("1. First 🥇\n2. Second 🥈", cfg)).toBe(
+			"1. First \n2. Second ",
+		);
+	});
+
+	test("strips emojis from markdown blockquotes", () => {
+		expect(runPipeline("> This is a quote 💭", cfg)).toBe("> This is a quote ");
+	});
+
+	test("strips emojis from markdown inline code", () => {
+		expect(runPipeline("Run `npm install 📦`", cfg)).toBe("Run `npm install `");
+	});
+
+	test("strips emojis from markdown code blocks", () => {
+		const input = "```javascript\nconsole.log('Success ✅');\n```";
+		const expected = "```javascript\nconsole.log('Success ');\n```";
+		expect(runPipeline(input, cfg)).toBe(expected);
+	});
+
+	test("strips emojis from markdown links and images", () => {
+		expect(runPipeline("[Click here 🔗](https://example.com)", cfg)).toBe(
+			"[Click here ](https://example.com)",
+		);
+		expect(runPipeline("![Image 🖼️](/path/to/img)", cfg)).toBe(
+			"![Image ](/path/to/img)",
+		);
+	});
+
+	test("strips emojis from markdown tables", () => {
+		const input = "| Col 1 🍎 | Col 2 🍌 |\n|---|---|\n| Val 1 🟢 | Val 2 🔴 |";
+		const expected = "| Col 1 | Col 2 |\n| ----- | ----- |\n| Val 1 | Val 2 |";
+		expect(runPipeline(input, cfg)).toBe(expected);
+	});
+
+	test("flushes table when followed by non-table text", () => {
+		const input = "| Col |\n|---|\n| Val |\n\nNormal text";
+		const expected = "| Col |\n| --- |\n| Val |\n\nNormal text";
+		expect(runPipeline(input, cfg)).toBe(expected);
+	});
+
+	test("strips emojis inside HTML tags within markdown", () => {
+		expect(runPipeline('<div title="Awesome 👍">Content 💯</div>', cfg)).toBe(
+			'<div title="Awesome ">Content </div>',
+		);
+	});
+
+	test("does NOT strip emojis when stripEmojis is false", () => {
+		expect(runPipeline("Hello 👋 World", cfgOff)).toBe("Hello 👋 World");
+	});
+});

package/tests/index.test.ts

@@ -0,0 +1,183 @@
+import {
+	afterEach,
+	beforeEach,
+	describe,
+	expect,
+	mock,
+	spyOn,
+	test,
+} from "bun:test";
+import fs from "node:fs";
+import fsp from "node:fs/promises";
+import { DEFAULT_CONFIG } from "../src/config";
+import { OpenCodeFmt, type PluginInput } from "../src/index";
+
+describe("Plugin Entry (index.ts)", () => {
+	const mockInput = {
+		directory: "/fake/dir",
+		client: {} as unknown,
+		project: {} as unknown,
+		worktree: "",
+		serverUrl: new URL("http://localhost"),
+		$: {} as unknown,
+	};
+
+	type TextCompleteHook = (
+		arg0: unknown,
+		arg1: { text: string },
+	) => Promise<void> | void;
+
+	beforeEach(() => {
+		spyOn(fsp, "appendFile").mockResolvedValue(undefined as undefined);
+		spyOn(fs, "existsSync");
+		spyOn(fs, "readFileSync");
+	});
+
+	afterEach(() => {
+		mock.restore();
+	});
+
+	test("initializes successfully with a valid config", async () => {
+		spyOn(fs, "existsSync").mockReturnValue(true);
+		spyOn(fs, "readFileSync").mockReturnValue(
+			JSON.stringify({ ...DEFAULT_CONFIG, logging: true }),
+		);
+
+		const hooks = await OpenCodeFmt(mockInput as PluginInput);
+
+		expect(hooks).toBeDefined();
+		expect(typeof hooks["experimental.text.complete"]).toBe("function");
+		expect(fsp.appendFile).toHaveBeenCalledWith(
+			expect.stringContaining("opencode-fmt.log"),
+			expect.stringContaining("Plugin Started"),
+		);
+	});
+
+	test("throws error when initializing with missing config", async () => {
+		spyOn(fs, "existsSync").mockReturnValue(false);
+
+		await expect(OpenCodeFmt(mockInput as PluginInput)).rejects.toThrow(
+			/Configuration file "config.json" is missing/,
+		);
+
+		expect(fsp.appendFile).toHaveBeenCalledWith(
+			expect.stringContaining("opencode-fmt.log"),
+			expect.stringContaining("FATAL STARTUP ERROR"),
+		);
+	});
+
+	test("hook processes text and strips emojis", async () => {
+		spyOn(fs, "existsSync").mockReturnValue(true);
+		spyOn(fs, "readFileSync").mockReturnValue(
+			JSON.stringify({ stripEmojis: true, logging: true }),
+		);
+
+		const hooks = await OpenCodeFmt(mockInput as PluginInput);
+		const textHook = hooks["experimental.text.complete"] as TextCompleteHook;
+
+		const hookOutput = { text: "Hello 🚀 World" };
+
+		await textHook({}, hookOutput);
+
+		expect(hookOutput.text).toBe("Hello  World");
+		expect(fsp.appendFile).toHaveBeenCalledWith(
+			expect.stringContaining("opencode-fmt.log"),
+			expect.stringContaining("| Duration: "),
+		);
+		expect(fsp.appendFile).toHaveBeenCalledWith(
+			expect.stringContaining("opencode-fmt.log"),
+			expect.stringContaining(
+				'Raw: "Hello 🚀 World" | Cleaned: "Hello  World"',
+			),
+		);
+	});
+
+	test("hook processes clean text without emitting 'Cleaned' log", async () => {
+		spyOn(fs, "existsSync").mockReturnValue(true);
+		spyOn(fs, "readFileSync").mockReturnValue(
+			JSON.stringify({ stripEmojis: true, logging: true }),
+		);
+
+		const hooks = await OpenCodeFmt(mockInput as PluginInput);
+		const textHook = hooks["experimental.text.complete"] as TextCompleteHook;
+
+		const hookOutput = { text: "No emojis here" };
+
+		await textHook({}, hookOutput);
+
+		expect(hookOutput.text).toBe("No emojis here");
+		expect(fsp.appendFile).toHaveBeenCalledWith(
+			expect.stringContaining("opencode-fmt.log"),
+			expect.stringContaining('Response: "No emojis here"'),
+		);
+	});
+
+	test("does not log anything when logging is false", async () => {
+		spyOn(fs, "existsSync").mockReturnValue(true);
+		spyOn(fs, "readFileSync").mockReturnValue(
+			JSON.stringify({ logging: false }),
+		);
+
+		const hooks = await OpenCodeFmt(mockInput as PluginInput);
+		const appendSpy = fsp.appendFile as { mockClear: () => void };
+		appendSpy.mockClear();
+
+		const textHook = hooks["experimental.text.complete"] as TextCompleteHook;
+		await textHook({}, { text: "Hello" });
+
+		expect(fsp.appendFile).not.toHaveBeenCalled();
+	});
+
+	test("hook logs performance metrics when logging is true", async () => {
+		spyOn(fs, "existsSync").mockReturnValue(true);
+		spyOn(fs, "readFileSync").mockReturnValue(
+			JSON.stringify({ logging: true }),
+		);
+
+		const hooks = await OpenCodeFmt(mockInput as PluginInput);
+		const textHook = hooks["experimental.text.complete"] as TextCompleteHook;
+
+		await textHook({}, { text: "Hello" });
+
+		expect(fsp.appendFile).toHaveBeenCalledWith(
+			expect.stringContaining("opencode-fmt.log"),
+			expect.stringContaining("Duration:"),
+		);
+	});
+
+	test("handles error during appendFile gracefully", async () => {
+		spyOn(fs, "existsSync").mockReturnValue(true);
+		spyOn(fs, "readFileSync").mockReturnValue(
+			JSON.stringify({ logging: true }),
+		);
+		(
+			fsp.appendFile as { mockRejectedValueOnce: (err: Error) => void }
+		).mockRejectedValueOnce(new Error("Disk Full"));
+
+		const hooks = await OpenCodeFmt(mockInput as PluginInput);
+		const textHook = hooks["experimental.text.complete"] as TextCompleteHook;
+
+		const hookOutput = { text: "Hello" };
+		await textHook({}, hookOutput);
+
+		expect(hookOutput.text).toBe("Hello");
+	});
+
+	test("trigger FATAL STARTUP ERROR path in OpenCodeFmt", async () => {
+		spyOn(fs, "existsSync").mockReturnValue(true);
+		spyOn(fs, "readFileSync").mockImplementation(() => {
+			throw new Error("Critical FS Error");
+		});
+
+		await expect(OpenCodeFmt(mockInput as PluginInput)).rejects.toThrow(
+			/\[opencode-fmt\] Failed to parse config\.json: Critical FS Error/,
+		);
+
+		expect(fsp.appendFile).toHaveBeenCalledWith(
+			expect.stringContaining("opencode-fmt.log"),
+			expect.stringContaining(
+				"FATAL STARTUP ERROR: [opencode-fmt] Failed to parse config.json: Critical FS Error",
+			),
+		);
+	});
+});

package/tsconfig.json

@@ -0,0 +1,15 @@
+{
+	"compilerOptions": {
+		"target": "ESNext",
+		"module": "ESNext",
+		"moduleResolution": "bundler",
+		"strict": true,
+		"outDir": "./dist",
+		"rootDir": "./src",
+		"declaration": true,
+		"skipLibCheck": true,
+		"allowJs": true,
+		"esModuleInterop": true
+	},
+	"include": ["src"]
+}