@hheei/omp-optimizer 0.1.0

package/src/status.test.ts

@@ -0,0 +1,84 @@
+import { describe, expect, it } from "bun:test";
+import { OptimizerStatus, renderStatus, STATUS_KEY, toolIcon } from "./status.ts";
+
+/** Tagging colorizer: <accent>X</accent> / <dim>X</dim> for assertions. */
+const tag = (c: string, t: string) => `<${c}>${t}</${c}>`;
+
+// Nerd Font glyphs are the extension's stable visual identity in OMP's TUI.
+const CV = toolIcon("caveman");
+const RK = toolIcon("rtk");
+const PT = toolIcon("ponytail");
+const T2S = toolIcon("t2s");
+const EG = toolIcon("edit-guard");
+describe("renderStatus", () => {
+	it("shows ALL icons in order, accent when enabled", () => {
+		expect(renderStatus({ caveman: true, rtk: true, ponytail: true, t2s: true, "edit-guard": true }, tag)).toBe(
+			`<accent>${CV}</accent>  <accent>${RK}</accent>  <accent>${PT}</accent>  <accent>${T2S}</accent>  <accent>${EG}</accent> `,
+		);
+	});
+
+	it("dims disabled tools but still shows them", () => {
+		expect(renderStatus({ caveman: false, rtk: true, ponytail: true, t2s: true, "edit-guard": true }, tag)).toBe(
+			`<dim>${CV}</dim>  <accent>${RK}</accent>  <accent>${PT}</accent>  <accent>${T2S}</accent>  <accent>${EG}</accent> `,
+		);
+	});
+
+	it("all dim when nothing enabled (cell never empty)", () => {
+		expect(renderStatus({}, tag)).toBe(`<dim>${CV}</dim>  <dim>${RK}</dim>  <dim>${PT}</dim>  <dim>${T2S}</dim>  <dim>${EG}</dim> `);
+	});
+
+	it("preserves fixed order regardless of insertion order", () => {
+		expect(renderStatus({ ponytail: true, caveman: true }, tag)).toBe(
+			`<accent>${CV}</accent>  <dim>${RK}</dim>  <accent>${PT}</accent>  <dim>${T2S}</dim>  <dim>${EG}</dim> `,
+		);
+	});
+
+	it("uses the optimizer Nerd Font icon catalog", () => {
+		expect([CV, RK, PT, T2S, EG]).toEqual(["\u{F0710}", "\u{F04E5}", "\u{F0190}", "\u{F0AC}", "\u{F132}"]);
+	});
+});
+
+describe("OptimizerStatus", () => {
+	/** Minimal ui stub capturing setStatus calls. */
+	function fakeCtx() {
+		const calls: { key: string; text: string }[] = [];
+		return {
+			calls,
+			ui: {
+				setStatus: (key: string, text: string | undefined) => calls.push({ key, text: text ?? "" }),
+				theme: { fg: (c: string, t: string) => `<${c}>${t}</${c}>` },
+			},
+		} as const;
+	}
+
+	it("paints the shared key with per-icon accent/dim", () => {
+		const status = new OptimizerStatus();
+		const ctx = fakeCtx();
+		status.set("rtk", true, ctx as never);
+		const last = ctx.calls.at(-1);
+		if (!last) throw new Error("no calls");
+		expect(last.key).toBe(STATUS_KEY);
+		// caveman + ponytail + edit guard still unset (dim), rtk accent.
+		expect(last.text).toBe(`<dim>${CV}</dim>  <accent>${RK}</accent>  <dim>${PT}</dim>  <dim>${T2S}</dim>  <dim>${EG}</dim> `);
+	});
+
+	it("accumulates state across tools", () => {
+		const status = new OptimizerStatus();
+		const ctx = fakeCtx();
+		status.set("caveman", true, ctx as never);
+		status.set("ponytail", true, ctx as never);
+		const last = ctx.calls.at(-1);
+		if (!last) throw new Error("no calls");
+		expect(last.text).toBe(`<accent>${CV}</accent>  <dim>${RK}</dim>  <accent>${PT}</accent>  <dim>${T2S}</dim>  <dim>${EG}</dim> `);
+	});
+
+	it("dims an icon when its tool toggles off (cell stays populated)", () => {
+		const status = new OptimizerStatus();
+		const ctx = fakeCtx();
+		status.set("rtk", true, ctx as never);
+		status.set("rtk", false, ctx as never);
+		const last = ctx.calls.at(-1);
+		if (!last) throw new Error("no calls");
+		expect(last.text).toBe(`<dim>${CV}</dim>  <dim>${RK}</dim>  <dim>${PT}</dim>  <dim>${T2S}</dim>  <dim>${EG}</dim> `);
+	});
+});

package/src/status.ts

@@ -0,0 +1,61 @@
+/** Shared status-bar state for the optimizer tools. */
+
+import type { ExtensionCommandContext, ExtensionContext, ThemeColor } from "@oh-my-pi/pi-coding-agent";
+
+export interface OptimizerHandle {
+	name: OptimizerTool;
+	help: string;
+	values: readonly string[];
+	current(): string;
+	run(value: string, ctx: ExtensionCommandContext): Promise<void> | void;
+}
+
+export const STATUS_KEY = "omp-optimizer";
+export type OptimizerTool = "caveman" | "rtk" | "ponytail" | "t2s" | "edit-guard";
+
+/** Optimizer-specific Nerd Font glyphs, matching pix-optimizer's catalog. */
+const TOOL_GLYPH: Record<OptimizerTool, string> = {
+	caveman: "\u{F0710}",
+	rtk: "\u{F04E5}",
+	ponytail: "\u{F0190}",
+	t2s: "\u{F0AC}",
+	"edit-guard": "\u{F132}",
+};
+
+export const OPTIMIZER_ICON = "\u{F0DAB}";
+
+export function toolIcon(tool: OptimizerTool): string {
+	return TOOL_GLYPH[tool];
+}
+
+const TOOL_ORDER: readonly OptimizerTool[] = ["caveman", "rtk", "ponytail", "t2s", "edit-guard"];
+const ENABLED_COLOR: ThemeColor = "accent";
+const DISABLED_COLOR: ThemeColor = "dim";
+
+export type Colorize = (color: ThemeColor, text: string) => string;
+
+export function renderStatus(
+	states: Partial<Record<OptimizerTool, boolean>>,
+	color: Colorize,
+): string {
+	return `${TOOL_ORDER.map(tool => color(states[tool] === true ? ENABLED_COLOR : DISABLED_COLOR, toolIcon(tool))).join("  ")} `;
+}
+
+export class OptimizerStatus {
+	#states: Partial<Record<OptimizerTool, boolean>> = {};
+	// Status is repainted by each lifecycle context; no global icon listener is needed.
+
+	get(tool: OptimizerTool): boolean | undefined {
+		return this.#states[tool];
+	}
+
+	set(tool: OptimizerTool, enabled: boolean, ctx: Pick<ExtensionContext, "ui">): void {
+		this.#states[tool] = enabled;
+		this.paint(ctx);
+	}
+
+	paint(ctx: Pick<ExtensionContext, "ui">): void {
+		const text = renderStatus(this.#states, (color, value) => ctx.ui.theme.fg(color, value));
+		ctx.ui.setStatus(STATUS_KEY, text);
+	}
+}

package/src/t2s.test.ts

@@ -0,0 +1,15 @@
+import { describe, expect, test } from "bun:test";
+import { convertInputText } from "./t2s.ts";
+
+describe("optimizer t2s", () => {
+	test("converts Traditional Chinese prose", () => {
+		expect(convertInputText("甚麼設定需要幫忙？")).toBe("什么设定需要帮忙？");
+	});
+
+	test("preserves inline and fenced code", () => {
+		const input = "請看 `甚麼`\n```ts\n甚麼設定\n```\n~~~txt\n最後設定\n~~~\n最後設定";
+		expect(convertInputText(input)).toBe(
+			"请看 `甚麼`\n```ts\n甚麼設定\n```\n~~~txt\n最後設定\n~~~\n最后设定",
+		);
+	});
+});

package/src/t2s.ts

@@ -0,0 +1,122 @@
+import OpenCC from "opencc-js/t2cn";
+import type { ExtensionAPI, ExtensionCommandContext, ExtensionContext } from "@oh-my-pi/pi-coding-agent";
+import { loadOptValue, saveOptValue } from "./persist.ts";
+import type { OptimizerHandle, OptimizerStatus } from "./status.ts";
+
+interface Fence {
+	readonly char: "`" | "~";
+	readonly length: number;
+}
+
+export type T2sLevel = "on" | "off";
+export const T2S_LEVELS: readonly T2sLevel[] = ["on", "off"];
+const toSimplified = OpenCC.Converter({ from: "tw", to: "cn" });
+
+function matchFence(line: string): Fence | undefined {
+	let start = 0;
+	while (start < line.length && (line[start] === " " || line[start] === "\t")) start++;
+	const char = line[start];
+	if (char !== "`" && char !== "~") return undefined;
+	let end = start;
+	while (end < line.length && line[end] === char) end++;
+	return end - start >= 3 ? { char, length: end - start } : undefined;
+}
+
+function proseLine(line: string): string {
+	let output = "";
+	let cursor = 0;
+	while (cursor < line.length) {
+		const openStart = line.indexOf("`", cursor);
+		if (openStart < 0) return output + toSimplified(line.slice(cursor)).replaceAll("甚么", "什么");
+		output += toSimplified(line.slice(cursor, openStart)).replaceAll("甚么", "什么");
+		let openEnd = openStart;
+		while (openEnd < line.length && line[openEnd] === "`") openEnd++;
+		const delimiterLength = openEnd - openStart;
+		let searchFrom = openEnd;
+		let closeEnd = -1;
+		while (searchFrom < line.length) {
+			const candidateStart = line.indexOf("`", searchFrom);
+			if (candidateStart < 0) break;
+			let candidateEnd = candidateStart;
+			while (candidateEnd < line.length && line[candidateEnd] === "`") candidateEnd++;
+			if (candidateEnd - candidateStart === delimiterLength) {
+				closeEnd = candidateEnd;
+				break;
+			}
+			searchFrom = candidateEnd;
+		}
+		if (closeEnd < 0) return output + line.slice(openStart);
+		output += line.slice(openStart, closeEnd);
+		cursor = closeEnd;
+	}
+	return output;
+}
+
+export function convertInputText(text: string): string {
+	const lines = text.split("\n");
+	let activeFence: Fence | undefined;
+	let output = "";
+	for (let index = 0; index < lines.length; index++) {
+		const line = lines[index];
+		if (line === undefined) continue;
+		const hasLineFeed = index < lines.length - 1;
+		const fence = matchFence(line);
+		if (activeFence) {
+			output += line + (hasLineFeed ? "\n" : "");
+			if (fence?.char === activeFence.char && fence.length >= activeFence.length) activeFence = undefined;
+		} else if (fence) {
+			activeFence = fence;
+			output += line + (hasLineFeed ? "\n" : "");
+		} else {
+			output += proseLine(line) + (hasLineFeed ? "\n" : "");
+		}
+	}
+	return output;
+}
+
+
+export function t2s(pi: ExtensionAPI, status: OptimizerStatus): OptimizerHandle {
+	let level: T2sLevel = "on";
+
+	function syncStatus(ctx: Pick<ExtensionContext, "ui">) {
+		status.set("t2s", level === "on", ctx);
+	}
+
+	pi.on("input", (event, _ctx) => {
+		if (level !== "on" || event.source !== "interactive") return undefined;
+		const text = convertInputText(event.text);
+		return text === event.text ? undefined : { action: "transform", text };
+	});
+
+	pi.on("session_start", async (_event, ctx) => {
+		for (const entry of ctx.sessionManager.getEntries()) {
+			if (entry.type !== "custom" || entry.customType !== "t2s-level") continue;
+			const saved = entry.data && typeof entry.data === "object" && "level" in entry.data ? entry.data.level : undefined;
+			if (saved === "on" || saved === "off") level = saved;
+		}
+		const saved = loadOptValue("t2s");
+		if (saved === "on" || saved === "off") level = saved;
+		syncStatus(ctx);
+	});
+
+	pi.on("agent_start", async (_event, ctx) => syncStatus(ctx));
+	pi.on("agent_end", async (_event, ctx) => syncStatus(ctx));
+
+	async function run(value: string, ctx: ExtensionCommandContext): Promise<void> {
+		if (value !== "on" && value !== "off") return;
+		level = value;
+		pi.appendEntry("t2s-level", { level });
+		saveOptValue("t2s", level);
+		syncStatus(ctx);
+		ctx.ui.notify(`T2S ${level === "on" ? "enabled" : "disabled"}`, "info");
+	}
+
+
+	return {
+		name: "t2s",
+		help: "t2s — convert Traditional Chinese input to Simplified Chinese",
+		values: T2S_LEVELS,
+		current: () => level,
+		run,
+	};
+}

package/src/tool-result-filter.test.ts

@@ -0,0 +1,96 @@
+import { describe, expect, it } from "bun:test";
+import { filterModelWarnings, stripModelWarningParagraphs } from "./tool-result-filter.ts";
+
+// ── stripModelWarningParagraphs ───────────────────────────────────────────────
+
+describe("stripModelWarningParagraphs", () => {
+	it("passes through text with no warnings", () => {
+		const text = "Exit code: 0\n\nsome output here";
+		expect(stripModelWarningParagraphs(text)).toBe(text);
+	});
+
+	it("strips a BLIND WRITE paragraph", () => {
+		const text =
+			"Exit code: 0\n\nsome output\n\n⚠ BLIND WRITE — editing `foo.ts` without reading in the last 5 tool calls. Read the file first to avoid assumptions.";
+		const result = stripModelWarningParagraphs(text);
+		expect(result).not.toContain("BLIND WRITE");
+		expect(result).toContain("some output");
+	});
+
+	it("strips a THRASHING paragraph", () => {
+		const text =
+			"ok\n\n🔴 THRASHING — 3 consecutive `edit` calls on foo.ts. Consider reading first.";
+		const result = stripModelWarningParagraphs(text);
+		expect(result).not.toContain("THRASHING");
+		expect(result).toContain("ok");
+	});
+
+	it("strips multiple warning paragraphs", () => {
+		const text = "output\n\n⚠ BLIND WRITE — foo\n\n🔴 THRASHING — bar\n\nmore output";
+		const result = stripModelWarningParagraphs(text);
+		expect(result).not.toContain("BLIND WRITE");
+		expect(result).not.toContain("THRASHING");
+		expect(result).toContain("output");
+		expect(result).toContain("more output");
+	});
+
+	it("returns original reference when nothing stripped", () => {
+		const text = "no warnings here";
+		expect(stripModelWarningParagraphs(text)).toBe(text);
+	});
+
+	it("trims trailing whitespace after stripping", () => {
+		const text = "output\n\n⚠ BLIND WRITE — foo";
+		const result = stripModelWarningParagraphs(text);
+		expect(result).toBe("output");
+	});
+
+	it("does not strip mid-paragraph BLIND WRITE mentions", () => {
+		// Only strips when the paragraph *starts* with the prefix
+		const text = "The BLIND WRITE check is a feature.\n\nsome output";
+		expect(stripModelWarningParagraphs(text)).toBe(text);
+	});
+});
+
+// ── filterModelWarnings ───────────────────────────────────────────────────────
+
+describe("filterModelWarnings", () => {
+	it("returns original array when no warnings present", () => {
+		const content = [{ type: "text" as const, text: "clean output" }];
+		expect(filterModelWarnings(content)).toBe(content);
+	});
+
+	it("filters BLIND WRITE from text block", () => {
+		const content = [
+			{
+				type: "text" as const,
+				text: "Exit code: 0\n\nok\n\n⚠ BLIND WRITE — editing `x.ts` without reading.",
+			},
+		];
+		const result = filterModelWarnings(content);
+		expect(result).not.toBe(content);
+		expect(result[0]?.type).toBe("text");
+		if (result[0]?.type === "text") {
+			expect((result[0] as { type: string; text: string }).text).not.toContain("BLIND WRITE");
+		}
+	});
+
+	it("leaves image blocks untouched", () => {
+		const img = { type: "image", source: { type: "base64", data: "abc" } };
+		const content = [img] as never[];
+		expect(filterModelWarnings(content)).toBe(content);
+	});
+
+	it("only modifies affected blocks, keeps others by reference", () => {
+		const clean = { type: "text" as const, text: "clean" };
+		const dirty = {
+			type: "text" as const,
+			text: "output\n\n⚠ BLIND WRITE — foo",
+		};
+		const content = [clean, dirty];
+		const result = filterModelWarnings(content);
+		// The array is new but clean block is the same reference
+		expect(result[0]).toBe(clean);
+		expect(result[1]).not.toBe(dirty);
+	});
+});

package/src/tool-result-filter.ts

@@ -0,0 +1,53 @@
+/**
+ * tool-result-filter.ts — strip model-guidance text from tool_result content.
+ *
+ * pi-lens appends diagnostic strings (BLIND WRITE, THRASHING) to tool_result
+ * content as guidance for the LLM. These are not useful to the user and clutter
+ * the TUI. This module filters them out of content blocks before they render.
+ *
+ * Patterns are anchored to the start of a paragraph (preceded by \n\n) so we
+ * don't accidentally clip real output that happens to contain these strings.
+ */
+
+import type { ImageContent, TextContent } from "@oh-my-pi/pi-ai";
+
+export type ToolContent = TextContent | ImageContent;
+
+/**
+ * Paragraph prefixes that identify model-only guidance injected by pi-lens.
+ * Each pattern matches from the start of a \n\n-delimited paragraph.
+ */
+const MODEL_WARNING_PREFIXES = ["⚠ BLIND WRITE —", "🔴 THRASHING —"] as const;
+
+/**
+ * Strip model-guidance paragraphs from a single text block's content.
+ * Returns the original string if nothing was removed.
+ */
+export function stripModelWarningParagraphs(text: string): string {
+	// Split on double-newline paragraph boundaries, filter out guidance paragraphs,
+	// then rejoin. Trim trailing whitespace from the result.
+	const paragraphs = text.split(/\n\n/);
+	const kept = paragraphs.filter(
+		(p) => !MODEL_WARNING_PREFIXES.some((prefix) => p.trimStart().startsWith(prefix)),
+	);
+	if (kept.length === paragraphs.length) return text;
+	return kept.join("\n\n").trimEnd();
+}
+
+/**
+ * Filter model-guidance warnings from an array of tool content blocks.
+ * Returns the original array reference if no blocks were modified.
+ */
+export function filterModelWarnings(content: ToolContent[]): ToolContent[] {
+	let changed = false;
+	const result = content.map((block) => {
+		if (block.type !== "text") return block;
+		const text = (block as TextContent).text;
+		if (typeof text !== "string") return block;
+		const filtered = stripModelWarningParagraphs(text);
+		if (filtered === text) return block;
+		changed = true;
+		return { ...block, text: filtered } as TextContent;
+	});
+	return changed ? result : content;
+}

package/tsconfig.json

@@ -0,0 +1,7 @@
+{
+	"extends": "../../tsconfig.workspace.json",
+	"compilerOptions": {
+		"allowImportingTsExtensions": true
+	},
+	"include": ["src"]
+}