opencode-fmt 0.1.0 → 0.2.0

package/README.md

@@ -1,58 +1,122 @@
-# OpenCode FMT Plugin
+# OpenCode FMT
 
-A unified, single-pass text optimization plugin for OpenCode that sanitizes emojis and formats markdown tables deterministically.
+[![Bun Version](https://img.shields.io/badge/Bun-%3E%3D1.3.11-blue?logo=bun&logoColor=white)](https://bun.sh)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+A unified text optimization plugin for **OpenCode** that sanitizes emojis and formats markdown tables. Built for high-performance pipelines where minimal latency is a requirement.
+
+---
 
 ## 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.
+- **Deterministic Emoji Sanitizer:** Removes emojis from AI outputs without altering the surrounding whitespace or layout.
+- **Isolated Table Aligner:** Formats Markdown tables by calculating maximum column widths and applying deterministic padding, ensuring visual correctness.
+- **Low-Latency Engine:** Processes AI output efficiently without a full AST-based parser, maintaining near-linear time processing.
+- **Concealment-Aware Widths:** Intelligently calculates table widths by accounting for markdown markers like **bold**, *italics*, **bold**, or *italics* which are hidden in many views.
+- **Flat Configuration:** Simple, flat boolean configuration file with nested-object validation.
 
-## Installation
+---
 
-This is an OpenCode-native TypeScript plugin. OpenCode executes it via Bun. 
+## Quick Start
 
-There are no external parsing dependencies required.
+## Plugin Configuration
+
+Add the plugin name to your OpenCode config file `plugins` section in `~/.config/opencode/config.json`:
 
 ```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"
-  }
+  "plugins": [
+    "opencode-fmt"
+  ]
 }
 ```
 
-## Configuration
+### Configuration
 
-Create a `config.json` inside your plugin root directory. The plugin only accepts a flat structure.
+The plugin automatically initializes a default configuration at `~/.config/opencode/fmt/config.json` on its first run if it doesn't already exist.
 
 ```json
 {
   "stripEmojis": true,
   "alignTables": true,
-  "logMetrics": false
+  "concealmentAware": true,
+  "logging": false
 }
 ```
 
-## Performance
+> [!NOTE]
+> All configuration keys are **booleans**. Top-level arrays and unknown keys in `config.json` are accepted for forward compatibility, but current core behavior only uses the documented keys below. Nested objects are strictly prohibited.
+
+| Key | Default | Description |
+| :--- | :--- | :--- |
+| `stripEmojis` | `true` | Removes all emojis from the output. |
+| `alignTables` | `true` | Dynamically aligns Markdown tables for visual consistency. |
+| `concealmentAware` | `true` | Accounts for hidden markdown markers (e.g. `**`, `_`) in column widths. |
+| `logging` | `false` | Enables duration and raw/clean output logging to `opencode-fmt.log`. |
+
+---
+
+## Examples
+
+### Emoji Sanitization
+
+The sanitizer removes pictographic and dingbat symbols from the text stream.
+
+**Before:** `Hello [hand-wave], our launch [rocket] was a success [party]!`  
+**After:** `Hello , our launch  was a success !`
+
+*(Note: Surrounding whitespaces are strictly preserved for deterministic layout stability, which may result in double spaces where an emoji was removed).*
+
+> [!NOTE]
+> If a response contains only emojis (and optional whitespace characters), `opencode-fmt` will replace it with a redaction placeholder:  
+> `[Only emojis received and redacted by opencode-fmt]`
+
+### Table Alignment
+
+The aligner intelligently pads columns based on the longest cell in each column.
+
+**Before:**
+
+```markdown
+| Header 1 | H2 |
+|---|---|
+| Val | Long Value |
+```
+
+**After:**
+
+```markdown
+| Header 1 | H2         |
+| -------- | ---------- |
+| Val      | Long Value |
+```
+
+---
+
+## Architectural Constraints
+
+This plugin is governed by strict technical rules to preserve its performance:
+
+1. **AST-Free Processing:** No heavyweight parsing into an Abstract Syntax Tree.
+2. **Zero Runtime Dependencies:** Built purely on native Bun/Node APIs and the core plugin hook.
+3. **Flat Config:** No nested objects are allowed in `config.json` to prevent parsing overhead. The configuration is stored in `~/.config/opencode/fmt/config.json`. Top-level arrays are permitted for list-based features. Any unknown keys are merged but ignored by core logic.
+4. **Diff Stability:** Non-target text (pure paragraphs) is preserved byte-for-byte in the output.
+
+---
+
+## Inspiration
+
+This plugin was inspired by two community plugins that pioneered single-feature plugin design:
+
+- **[opencode-md-table-formatter](https://github.com/franlol/opencode-md-table-formatter)** by @franlol — Automatic Markdown table formatting with concealment mode support
+- **[opencode-unmoji](https://codeberg.org/bastiangx/opencode-unmoji)** by @bastiangx — Strips emojis from agent output
+
+Both showed that focused, lightweight plugins can solve specific pain points elegantly. This plugin follows the same philosophy: one concern, done well.
 
-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`)
+## License
 
-## Architectural Constraints (Strict)
+This project is licensed under the **MIT License**. See the [LICENSE](LICENSE) file for details.
 
-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.
+© 2026 Ritesh Kumar Pal

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "opencode-fmt",
-	"version": "0.1.0",
+	"version": "0.2.0",
 	"type": "module",
 	"main": "dist/index.js",
 	"exports": {
@@ -23,4 +23,4 @@
 	"peerDependencies": {
 		"typescript": "^5"
 	}
-}
+}

package/src/config.ts

@@ -1,25 +1,38 @@
 import fs from "node:fs";
+import os from "node:os";
 import path from "node:path";
 
 export interface PluginConfig {
 	stripEmojis: boolean;
 	alignTables: boolean;
+	concealmentAware: boolean;
 	logging: boolean;
 }
 
 export const DEFAULT_CONFIG: PluginConfig = {
 	stripEmojis: true,
 	alignTables: true,
+	concealmentAware: true,
 	logging: false,
 };
 
-export function loadConfig(pluginDir: string): PluginConfig {
-	const configPath = path.join(pluginDir, "config.json");
+export function getConfigDir(): string {
+	const configDir = path.join(os.homedir(), ".config", "opencode", "fmt");
+	fs.mkdirSync(configDir, { recursive: true });
+	return configDir;
+}
+
+export function loadConfig(): PluginConfig {
+	const configDir = getConfigDir();
+	const configPath = path.join(configDir, "config.json");
 
 	if (!fs.existsSync(configPath)) {
-		throw new Error(
-			`[opencode-fmt] Configuration file "config.json" is missing. Please create it in the project root.`,
+		fs.writeFileSync(
+			configPath,
+			JSON.stringify(DEFAULT_CONFIG, null, "\t"),
+			"utf-8",
 		);
+		return { ...DEFAULT_CONFIG };
 	}
 
 	let rawConfig: Record<string, unknown> = {};
@@ -38,28 +51,24 @@ export function loadConfig(pluginDir: string): PluginConfig {
 	}
 
 	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;
+		if (Object.hasOwn(DEFAULT_CONFIG, key)) {
+			const expectedType = typeof DEFAULT_CONFIG[key as keyof PluginConfig];
+			if (typeof value === expectedType) {
+				(finalConfig as unknown as Record<string, unknown>)[key] = value;
+			} else {
+				throw new Error(
+					`[opencode-fmt] Config Error: Invalid type for "${key}". Expected ${expectedType}, got ${typeof value}.`,
+				);
+			}
+		} else {
+			(finalConfig as unknown as Record<string, unknown>)[key] = value;
+		}
 	}
-
 	return finalConfig as PluginConfig;
 }

package/src/emoji-sanitizer.ts

@@ -1,6 +1,5 @@
-export const EMOJI_REGEX =
+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

@@ -1,36 +1,46 @@
 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 lines = text.split(/\r?\n/);
+	const isCRLF = text.includes("\r\n");
 	const resultLines: string[] = [];
-
 	let isInTable = false;
 	let tableBuffer: string[] = [];
-
+	let hasSeparator = false;
 	const flushTable = () => {
 		if (tableBuffer.length > 0) {
-			const output = config.alignTables ? alignTable(tableBuffer) : tableBuffer;
+			const output =
+				config.alignTables && hasSeparator
+					? alignTable(tableBuffer, config.concealmentAware)
+					: tableBuffer;
 			resultLines.push(...output);
 			tableBuffer = [];
+			hasSeparator = false;
 		}
 	};
-
 	for (const line of lines) {
 		let processedLine = line;
-
 		if (config.stripEmojis) {
 			processedLine = sanitizeEmojis(processedLine);
 		}
-
-		const isTableRow = processedLine.trim().startsWith("|");
-
+		const trimmedLine = processedLine.trim();
+		const isTableRow = trimmedLine.startsWith("|");
 		if (isTableRow) {
 			isInTable = true;
 			tableBuffer.push(processedLine);
+			const content = trimmedLine.slice(1, -1);
+			if (
+				content.length > 0 &&
+				/^[|\s:.-]+$/.test(content) &&
+				content.includes("-")
+			) {
+				const cells = content.split("|");
+				if (cells.every((c) => /^\s*:?-+:?\s*$/.test(c))) {
+					hasSeparator = true;
+				}
+			}
 		} else {
 			if (isInTable) {
 				flushTable();
@@ -39,14 +49,11 @@ export function runPipeline(text: string, config: PluginConfig): string {
 			resultLines.push(processedLine);
 		}
 	}
-
 	flushTable();
-
-	const result = resultLines.join("\n");
-
+	const lineEnding = isCRLF ? "\r\n" : "\n";
+	const result = resultLines.join(lineEnding);
 	if (text.trim().length > 0 && result.trim().length === 0) {
 		return "[Only emojis received and redacted by opencode-fmt]";
 	}
-
 	return result;
 }

package/src/index.ts

@@ -1,23 +1,19 @@
 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 { getConfigDir, 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");
+	const configDir = getConfigDir();
+	const logPath = path.join(configDir, "opencode-fmt.log");
 
 	let config: PluginConfig;
 	try {
-		config = loadConfig(PLUGIN_DIR);
+		config = loadConfig();
 		if (config.logging) {
 			const bootMsg = `[opencode-fmt] ${new Date().toLocaleString()} | Plugin Started | Config: ${JSON.stringify(config)}\n`;
 			await fs.appendFile(logPath, bootMsg).catch(() => {});
@@ -31,25 +27,20 @@ export const OpenCodeFmt: Plugin = async (_input: PluginInput) => {
 	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(() => {});
+					await fs.appendFile(logPath, logMsg).catch(() => {});
 				} catch (_) {}
 			}
 		},

package/src/table-aligner.ts

@@ -1,27 +1,28 @@
 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);
+	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);
-
+function padCell(
+	cell: string,
+	width: number,
+	align: Alignment,
+	concealmentAware: boolean,
+): string {
+	const currentWidth = concealmentAware ? getVisualWidth(cell) : cell.length;
+	const padding = Math.max(0, width - currentWidth);
 	if (align === "center") {
 		const leftPad = Math.floor(padding / 2);
 		const rightPad = padding - leftPad;
@@ -32,55 +33,80 @@ function padCell(cell: string, width: number, align: Alignment): string {
 	}
 	return cell + " ".repeat(padding);
 }
-
-export function alignTable(rows: string[]): string[] {
+function getVisualWidth(text: string): number {
+	let processed = text.replace(/\[((?:[^[\]]+|\[[^\]]*\])*)\]\([^)]+\)/g, "$1");
+	processed = processed
+		.replace(/\\(.)/g, "$1")
+		.replace(/\*\*(.+?)\*\*/g, "$1")
+		.replace(/\*(.+?)\*/g, "$1")
+		.replace(/__(.+?)__/g, "$1")
+		.replace(/_(.+?)_/g, "$1")
+		.replace(/~~(.+?)~~/g, "$1")
+		.replace(/`([^`]+)`/g, "$1");
+	return processed.length;
+}
+export function alignTableWithConfig(
+	rows: string[],
+	concealmentAware: boolean,
+): 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));
-
+		const cells = trimmedRow
+			.split(/(?<!\\)\|/)
+			.map((c) => c.trim())
+			.filter((c, index, array) => {
+				if (index === 0 && c === "") return false;
+				if (index === array.length - 1 && c === "") return false;
+				return true;
+			});
+		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;
+				const cellLength = concealmentAware
+					? getVisualWidth(cells[j])
+					: cells[j].length;
 				if (colWidths[j] === undefined || cellLength > colWidths[j]) {
 					colWidths[j] = cellLength;
 				}
 			}
 		}
 	}
-
 	const colCount = colWidths.length;
-
+	for (let i = 0; i < colCount; i++) {
+		colWidths[i] = Math.max(3, colWidths[i] || 0);
+	}
 	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 width = colWidths[i];
 			const align = colAlignments[i] || "default";
-
 			if (row.isSeparator) {
 				paddedCells[i] = formatSeparator(width, align);
 			} else {
-				paddedCells[i] = padCell(cell, width, align);
+				paddedCells[i] = padCell(cell, width, align, concealmentAware);
 			}
 		}
 		return `| ${paddedCells.join(" | ")} |`;
 	});
 }
+export function alignTable(
+	rows: string[],
+	concealmentAware: boolean = true,
+): string[] {
+	return alignTableWithConfig(rows, concealmentAware);
+}

package/tests/aligner.test.ts

@@ -22,9 +22,9 @@ describe("Table Aligner", () => {
 	test("fills missing columns in short rows", () => {
 		const input = ["| H1 | H2 |", "|---|---|", "| Single |"];
 		const result = alignTable(input);
-		expect(result[0]).toBe("| H1     | H2 |");
+		expect(result[0]).toBe("| H1     | H2  |");
 		expect(result[1]).toBe("| ------ | --- |");
-		expect(result[2]).toBe("| Single |    |");
+		expect(result[2]).toBe("| Single |     |");
 	});
 
 	test("handles empty input", () => {
@@ -35,28 +35,140 @@ describe("Table Aligner", () => {
 		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 |");
+		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[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 input = [
+			"| Left | Center | Right |",
+			"| :--- | :---: | ---: |",
+			"| l | center | rvalue |",
+		];
+		const result = alignTable(input);
+		expect(result[0]).toBe("| Left | Center |  Right |");
+		expect(result[1]).toBe("| :--- | :----: | -----: |");
+		expect(result[2]).toBe("| l    | center | rvalue |");
+	});
+
+	test("handles single column center", () => {
+		const input = ["| A |", "|:--:|", "| x |"];
+		const result = alignTable(input);
+		expect(result[0]).toBe("|  A  |");
+		expect(result[1]).toBe("| :-: |");
+		expect(result[2]).toBe("|  x  |");
+	});
+
+	test("handles table without separator (defaults left)", () => {
+		const input = ["| A | B |", "| a | b |"];
+		const result = alignTable(input);
+		expect(result[0]).toBe("| A   | B   |");
+		expect(result[1]).toBe("| a   | b   |");
+	});
+
+	test("handles escaped pipes without splitting columns", () => {
+		const input = [
+			"| Header 1 | Header 2 |",
+			"| --- | --- |",
+			"| Value with \\| pipe | Next Col |",
+		];
+		const result = alignTable(input, true);
+		expect(result[2]).toContain("\\|");
+		const matches = result[2].match(/(?<!\\)\|/g);
+		expect(matches?.length).toBe(3);
+	});
+});
+
+describe("Concealment Aware Width Calculation", () => {
+	test("concealmentAware=true strips bold for width", () => {
+		const input = ["| Feature | Status |", "|---|---|", "| **bold** | Done |"];
+		const result = alignTable(input, true);
+		expect(result[0]).toBe("| Feature | Status |");
+		expect(result[1]).toBe("| ------- | ------ |");
+		expect(result[2]).toBe("| **bold**    | Done   |");
+	});
+
+	test("concealmentAware=true strips italic for width", () => {
+		const input = ["| Feature | Status |", "|---|---|", "| *italic* | Done |"];
+		const result = alignTable(input, true);
+		expect(result[2]).toBe("| *italic*  | Done   |");
+	});
+
+	test("concealmentAware=true strips underscore bold for width", () => {
+		const input = ["| Feature | Status |", "|---|---|", "| __bold__ | Done |"];
+		const result = alignTable(input, true);
+		expect(result[2]).toBe("| __bold__    | Done   |");
+	});
+
+	test("concealmentAware=true strips underscore italic for width", () => {
+		const input = ["| Feature | Status |", "|---|---|", "| _italic_ | Done |"];
+		const result = alignTable(input, true);
+		expect(result[2]).toBe("| _italic_  | Done   |");
+	});
+
+	test("concealmentAware=true strips strikethrough for width", () => {
+		const input = [
+			"| Feature | Status |",
+			"|---|---|",
+			"| ~~strike~~ | Done |",
+		];
+		const result = alignTable(input, true);
+		expect(result[2]).toBe("| ~~strike~~  | Done   |");
+	});
+
+	test("concealmentAware=false uses raw length", () => {
+		const input = ["| Feature | Status |", "|---|---|", "| **bold** | Done |"];
+		const result = alignTable(input, false);
+		expect(result[1]).toBe("| -------- | ------ |");
+		expect(result[2]).toBe("| **bold** | Done   |");
+	});
+
+	test("defaults to concealmentAware=true for backwards compatibility", () => {
+		const input = ["| A | B |", "|---|---|", "| **x** | y |"];
 		const result = alignTable(input);
-		expect(result[1]).toBe("| :--- | :-----: | ------: |");
-		expect(result[2]).toBe("| l   |  center | rvalue |");
+		expect(result).toEqual(alignTable(input, true));
+	});
+
+	test("mixed markdown in cells", () => {
+		const input = ["| Col1 | Col2 |", "|---|--- |", "| **bold** | *italic* |"];
+		const result = alignTable(input, true);
+		expect(result[2]).toBe("| **bold** | *italic* |");
+	});
+
+	test("concealmentAware=true should strip links for width", () => {
+		const input = [
+			"| Page | Link |",
+			"|---|---|",
+			"| Home | [Google](https://google.com) |",
+		];
+		const result = alignTable(input, true);
+		expect(result[0]).toBe("| Page | Link   |");
+		expect(result[1]).toBe("| ---- | ------ |");
+		expect(result[2]).toBe("| Home | [Google](https://google.com) |");
+	});
+
+	test("concealmentAware=true should strip escaped characters", () => {
+		const input = ["| A | B |", "|---|---|", "| \\* | \\*\\* |"];
+		const result = alignTable(input, true);
+		expect(result[2]).toBe("| \\*   | \\*\\*  |");
 	});
 });
 
 describe("Diff Stability", () => {
-	const cfg = { stripEmojis: false, alignTables: true, logMetrics: false };
+	const cfg = {
+		stripEmojis: false,
+		alignTables: true,
+		logging: false,
+		concealmentAware: true,
+	};
 
 	test("plain text with no tables passes through byte-identical", () => {
 		const input = "This is plain text.\nNo tables here.\nJust three lines.";

package/tests/config.test.ts

@@ -8,33 +8,37 @@ import {
 	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, "mkdirSync").mockImplementation(() => undefined);
 		spyOn(fs, "existsSync");
 		spyOn(fs, "readFileSync");
+		spyOn(fs, "writeFileSync").mockImplementation(() => undefined);
 	});
 
 	afterEach(() => {
 		mock.restore();
 	});
 
-	test("throws error if config.json is missing", () => {
+	test("creates config.json with defaults when file is missing and returns DEFAULT_CONFIG", () => {
 		spyOn(fs, "existsSync").mockReturnValue(false);
-		expect(() => loadConfig(dir)).toThrow(
-			/Configuration file "config.json" is missing/,
+
+		const config = loadConfig();
+
+		expect(fs.writeFileSync).toHaveBeenCalledWith(
+			expect.stringContaining("config.json"),
+			expect.stringContaining("stripEmojis"),
+			"utf-8",
 		);
+		expect(config).toEqual(DEFAULT_CONFIG);
 	});
 
 	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/);
+		expect(() => loadConfig()).toThrow(/Failed to parse config.json/);
 	});
 
 	test("loads config and merges with defaults", () => {
@@ -43,7 +47,7 @@ describe("Config Loader", () => {
 			JSON.stringify({ logging: true }),
 		);
 
-		const config = loadConfig(dir);
+		const config = loadConfig();
 
 		expect(config.logging).toBe(true);
 		expect(config.stripEmojis).toBe(DEFAULT_CONFIG.stripEmojis);
@@ -59,7 +63,7 @@ describe("Config Loader", () => {
 			}),
 		);
 
-		expect(() => loadConfig(dir)).toThrow(/Nested object at "nested"/);
+		expect(() => loadConfig()).toThrow(/Nested object at "nested"/);
 	});
 
 	test("allows arrays in config (e.g. for future list features)", () => {
@@ -71,7 +75,7 @@ describe("Config Loader", () => {
 			}),
 		);
 
-		const config = loadConfig(dir) as Record<string, unknown>;
+		const config = loadConfig() as Record<string, unknown>;
 		expect(config.ignoredPaths).toEqual(["node_modules"]);
 	});
 });

package/tests/engine.test.ts

@@ -1,8 +1,18 @@
 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 };
+const cfg = {
+	stripEmojis: true,
+	alignTables: true,
+	concealmentAware: true,
+	logging: false,
+};
+const cfgOff = {
+	stripEmojis: false,
+	alignTables: false,
+	concealmentAware: false,
+	logging: false,
+};
 
 describe("Emoji Sanitizer", () => {
 	test("strips a single emoji", () => {
@@ -37,6 +47,16 @@ describe("Emoji Sanitizer", () => {
 		);
 	});
 
+	test("returns redaction placeholder for emojis with newlines", () => {
+		expect(runPipeline("🚀 \n\n 🔥", cfg)).toBe(
+			"[Only emojis received and redacted by opencode-fmt]",
+		);
+	});
+
+	test("does NOT trigger redaction for plain whitespace messages", () => {
+		expect(runPipeline("   \n   ", cfg)).toBe("   \n   ");
+	});
+
 	test("preserves numbers and punctuation around emojis", () => {
 		expect(runPipeline("Step 1: 📋 check", cfg)).toBe("Step 1:  check");
 	});
@@ -133,4 +153,9 @@ describe("Emoji Sanitizer", () => {
 	test("does NOT strip emojis when stripEmojis is false", () => {
 		expect(runPipeline("Hello 👋 World", cfgOff)).toBe("Hello 👋 World");
 	});
+
+	test("does NOT format non-table lines starting with pipes", () => {
+		const input = "| This is just a line with a pipe\nSome other text";
+		expect(runPipeline(input, cfg)).toBe(input);
+	});
 });

package/tests/index.test.ts

@@ -29,6 +29,8 @@ describe("Plugin Entry (index.ts)", () => {
 
 	beforeEach(() => {
 		spyOn(fsp, "appendFile").mockResolvedValue(undefined as undefined);
+		spyOn(fs, "mkdirSync").mockImplementation(() => undefined);
+		spyOn(fs, "writeFileSync").mockImplementation(() => undefined);
 		spyOn(fs, "existsSync");
 		spyOn(fs, "readFileSync");
 	});
@@ -53,15 +55,19 @@ describe("Plugin Entry (index.ts)", () => {
 		);
 	});
 
-	test("throws error when initializing with missing config", async () => {
+	test("initializes with default config when config.json is missing", async () => {
 		spyOn(fs, "existsSync").mockReturnValue(false);
 
-		await expect(OpenCodeFmt(mockInput as PluginInput)).rejects.toThrow(
-			/Configuration file "config.json" is missing/,
-		);
+		const hooks = await OpenCodeFmt(mockInput as PluginInput);
 
-		expect(fsp.appendFile).toHaveBeenCalledWith(
-			expect.stringContaining("opencode-fmt.log"),
+		expect(hooks).toBeDefined();
+		expect(fs.writeFileSync).toHaveBeenCalledWith(
+			expect.stringContaining("config.json"),
+			expect.stringContaining("stripEmojis"),
+			"utf-8",
+		);
+		expect(fsp.appendFile).not.toHaveBeenCalledWith(
+			expect.anything(),
 			expect.stringContaining("FATAL STARTUP ERROR"),
 		);
 	});

package/debug.ts

@@ -1,16 +0,0 @@
-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/src/passes/echo.ts

@@ -1,11 +0,0 @@
-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

@@ -1,21 +0,0 @@
-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;
-}