@oh-my-pi/pi-coding-agent 4.1.0 → 4.2.1

package/src/core/custom-share.ts

@@ -0,0 +1,66 @@
+/**
+ * Custom share script loader.
+ *
+ * Allows users to define a custom share handler at ~/.omp/agent/share.ts
+ * that will be used instead of the default GitHub Gist sharing.
+ */
+
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import { getAgentDir } from "../config";
+
+export interface CustomShareResult {
+	/** URL to display/open (optional - script may handle everything itself) */
+	url?: string;
+	/** Additional message to show the user */
+	message?: string;
+}
+
+export type CustomShareFn = (htmlPath: string) => Promise<CustomShareResult | string | undefined>;
+
+interface LoadedCustomShare {
+	path: string;
+	fn: CustomShareFn;
+}
+
+const SHARE_SCRIPT_CANDIDATES = ["share.ts", "share.js", "share.mjs"];
+
+/**
+ * Get the path to the custom share script if it exists.
+ */
+export function getCustomSharePath(): string | null {
+	const agentDir = getAgentDir();
+
+	for (const candidate of SHARE_SCRIPT_CANDIDATES) {
+		const scriptPath = join(agentDir, candidate);
+		if (existsSync(scriptPath)) {
+			return scriptPath;
+		}
+	}
+
+	return null;
+}
+
+/**
+ * Load the custom share script if it exists.
+ */
+export async function loadCustomShare(): Promise<LoadedCustomShare | null> {
+	const scriptPath = getCustomSharePath();
+	if (!scriptPath) {
+		return null;
+	}
+
+	try {
+		const module = await import(scriptPath);
+		const fn = module.default;
+
+		if (typeof fn !== "function") {
+			throw new Error("share script must export a default function");
+		}
+
+		return { path: scriptPath, fn };
+	} catch (err) {
+		const message = err instanceof Error ? err.message : String(err);
+		throw new Error(`Failed to load share script: ${message}`);
+	}
+}

package/src/core/export-html/index.ts

@@ -1,7 +1,6 @@
 import { existsSync, writeFileSync } from "node:fs";
 import { basename } from "node:path";
-import type { AgentState, AgentTool } from "@oh-my-pi/pi-agent-core";
-import { buildCodexPiBridge, getCodexInstructions } from "@oh-my-pi/pi-ai";
+import type { AgentState } from "@oh-my-pi/pi-agent-core";
 import { APP_NAME } from "../../config";
 import { getResolvedThemeColors, getThemeExportColors } from "../../modes/interactive/theme/theme";
 import { SessionManager } from "../session-manager";
@@ -14,33 +13,6 @@ export interface ExportOptions {
 	themeName?: string;
 }
 
-/** Info about Codex injection to show inline with model_change entries. */
-interface CodexInjectionInfo {
-	/** Codex instructions text. */
-	instructions: string;
-	/** Bridge text (tool list). */
-	bridge: string;
-}
-
-/** Build Codex injection info for display inline with model_change entries. */
-async function buildCodexInjectionInfo(tools?: AgentTool[]): Promise<CodexInjectionInfo | undefined> {
-	let instructions: string | null = null;
-	try {
-		instructions = await getCodexInstructions("gpt-5.1-codex");
-	} catch {
-		// Cache miss is expected before the first Codex request.
-	}
-
-	const bridgeText = buildCodexPiBridge(tools);
-	const instructionsText =
-		instructions ?? "(Codex instructions not cached. Run a Codex request to populate the local cache.)";
-
-	return {
-		instructions: instructionsText,
-		bridge: bridgeText,
-	};
-}
-
 /** Parse a color string to RGB values. */
 function parseColor(color: string): { r: number; g: number; b: number } | undefined {
 	const hexMatch = color.match(/^#([0-9a-fA-F]{2})([0-9a-fA-F]{2})([0-9a-fA-F]{2})$/);
@@ -125,8 +97,6 @@ interface SessionData {
 	entries: ReturnType<SessionManager["getEntries"]>;
 	leafId: string | null;
 	systemPrompt?: string;
-	/** Info for rendering Codex injection inline with model_change entries. */
-	codexInjectionInfo?: CodexInjectionInfo;
 	tools?: { name: string; description: string }[];
 }
 
@@ -158,7 +128,6 @@ export async function exportSessionToHtml(
 		entries: sm.getEntries(),
 		leafId: sm.getLeafId(),
 		systemPrompt: state?.systemPrompt,
-		codexInjectionInfo: await buildCodexInjectionInfo(state?.tools),
 		tools: state?.tools?.map((t) => ({ name: t.name, description: t.description })),
 	};
 
@@ -180,7 +149,6 @@ export async function exportFromFile(inputPath: string, options?: ExportOptions
 		header: sm.getHeader(),
 		entries: sm.getEntries(),
 		leafId: sm.getLeafId(),
-		codexInjectionInfo: await buildCodexInjectionInfo(),
 	};
 
 	const html = generateHtml(sessionData, opts.themeName);

package/src/core/history-storage.ts

@@ -29,6 +29,9 @@ export class HistoryStorage {
 	private searchStmt: Statement;
 	private lastPromptStmt: Statement;
 
+	// In-memory cache of last prompt to avoid sync DB reads on add
+	private lastPromptCache: string | null = null;
+
 	private constructor(dbPath: string) {
 		this.ensureDir(dbPath);
 
@@ -71,6 +74,9 @@ END;
 			"SELECT h.id, h.prompt, h.created_at, h.cwd FROM history_fts f JOIN history h ON h.id = f.rowid WHERE history_fts MATCH ? ORDER BY h.created_at DESC, h.id DESC LIMIT ?",
 		);
 		this.lastPromptStmt = this.db.prepare("SELECT prompt FROM history ORDER BY id DESC LIMIT 1");
+
+		const last = this.lastPromptStmt.get() as { prompt?: string } | undefined;
+		this.lastPromptCache = last?.prompt ?? null;
 	}
 
 	static open(dbPath: string = join(getAgentDir(), "history.db")): HistoryStorage {
@@ -83,15 +89,17 @@ END;
 	add(prompt: string, cwd?: string): void {
 		const trimmed = prompt.trim();
 		if (!trimmed) return;
+		if (this.lastPromptCache === trimmed) return;
 
-		try {
-			const last = this.lastPromptStmt.get() as { prompt?: string } | undefined;
-			if (last?.prompt === trimmed) return;
+		this.lastPromptCache = trimmed;
 
-			this.insertStmt.run(trimmed, cwd ?? null);
-		} catch (error) {
-			logger.error("HistoryStorage add failed", { error: String(error) });
-		}
+		setImmediate(() => {
+			try {
+				this.insertStmt.run(trimmed, cwd ?? null);
+			} catch (error) {
+				logger.error("HistoryStorage add failed", { error: String(error) });
+			}
+		});
 	}
 
 	getRecent(limit: number): HistoryEntry[] {

package/src/core/prompt-templates.ts

@@ -1,4 +1,5 @@
 import { join, resolve } from "node:path";
+import Handlebars from "handlebars";
 import { CONFIG_DIR_NAME, getPromptsDir } from "../config";
 
 /**
@@ -11,6 +12,273 @@ export interface PromptTemplate {
 	source: string; // e.g., "(user)", "(project)", "(project:frontend)"
 }
 
+export interface TemplateContext extends Record<string, unknown> {
+	args?: string[];
+	ARGUMENTS?: string;
+	arguments?: string;
+}
+
+const handlebars = Handlebars.create();
+
+handlebars.registerHelper("arg", function (this: TemplateContext, index: number | string): string {
+	const args = this.args ?? [];
+	const parsedIndex = typeof index === "number" ? index : Number.parseInt(index, 10);
+	if (!Number.isFinite(parsedIndex)) return "";
+	const zeroBased = parsedIndex - 1;
+	if (zeroBased < 0) return "";
+	return args[zeroBased] ?? "";
+});
+
+/**
+ * {{#list items prefix="- " suffix="" join="\n"}}{{this}}{{/list}}
+ * Renders an array with customizable prefix, suffix, and join separator.
+ * Note: Use \n in join for newlines (will be unescaped automatically).
+ */
+handlebars.registerHelper(
+	"list",
+	function (this: unknown, context: unknown[], options: Handlebars.HelperOptions): string {
+		if (!Array.isArray(context) || context.length === 0) return "";
+		const prefix = (options.hash.prefix as string) ?? "";
+		const suffix = (options.hash.suffix as string) ?? "";
+		const rawSeparator = (options.hash.join as string) ?? "\n";
+		const separator = rawSeparator.replace(/\\n/g, "\n").replace(/\\t/g, "\t");
+		return context.map((item) => `${prefix}${options.fn(item)}${suffix}`).join(separator);
+	},
+);
+
+/**
+ * {{join array ", "}}
+ * Joins an array with a separator (default: ", ").
+ */
+handlebars.registerHelper("join", (context: unknown[], separator?: unknown): string => {
+	if (!Array.isArray(context)) return "";
+	const sep = typeof separator === "string" ? separator : ", ";
+	return context.join(sep);
+});
+
+/**
+ * {{default value "fallback"}}
+ * Returns the value if truthy, otherwise returns the fallback.
+ */
+handlebars.registerHelper("default", (value: unknown, defaultValue: unknown): unknown => value || defaultValue);
+
+/**
+ * {{pluralize count "item" "items"}}
+ * Returns "1 item" or "5 items" based on count.
+ */
+handlebars.registerHelper(
+	"pluralize",
+	(count: number, singular: string, plural: string): string => `${count} ${count === 1 ? singular : plural}`,
+);
+
+/**
+ * {{#when value "==" compare}}...{{else}}...{{/when}}
+ * Conditional block with comparison operators: ==, ===, !=, !==, >, <, >=, <=
+ */
+handlebars.registerHelper(
+	"when",
+	function (this: unknown, lhs: unknown, operator: string, rhs: unknown, options: Handlebars.HelperOptions): string {
+		const ops: Record<string, (a: unknown, b: unknown) => boolean> = {
+			"==": (a, b) => a === b,
+			"===": (a, b) => a === b,
+			"!=": (a, b) => a !== b,
+			"!==": (a, b) => a !== b,
+			">": (a, b) => (a as number) > (b as number),
+			"<": (a, b) => (a as number) < (b as number),
+			">=": (a, b) => (a as number) >= (b as number),
+			"<=": (a, b) => (a as number) <= (b as number),
+		};
+		const fn = ops[operator];
+		if (!fn) return options.inverse(this);
+		return fn(lhs, rhs) ? options.fn(this) : options.inverse(this);
+	},
+);
+
+/**
+ * {{#ifAny a b c}}...{{else}}...{{/ifAny}}
+ * True if any argument is truthy.
+ */
+handlebars.registerHelper("ifAny", function (this: unknown, ...args: unknown[]): string {
+	const options = args.pop() as Handlebars.HelperOptions;
+	return args.some(Boolean) ? options.fn(this) : options.inverse(this);
+});
+
+/**
+ * {{#ifAll a b c}}...{{else}}...{{/ifAll}}
+ * True if all arguments are truthy.
+ */
+handlebars.registerHelper("ifAll", function (this: unknown, ...args: unknown[]): string {
+	const options = args.pop() as Handlebars.HelperOptions;
+	return args.every(Boolean) ? options.fn(this) : options.inverse(this);
+});
+
+/**
+ * {{#table rows headers="Col1|Col2"}}{{col1}}|{{col2}}{{/table}}
+ * Generates a markdown table from an array of objects.
+ */
+handlebars.registerHelper(
+	"table",
+	function (this: unknown, context: unknown[], options: Handlebars.HelperOptions): string {
+		if (!Array.isArray(context) || context.length === 0) return "";
+		const headersStr = options.hash.headers as string | undefined;
+		const headers = headersStr?.split("|") ?? [];
+		const separator = headers.map(() => "---").join(" | ");
+		const headerRow = headers.length > 0 ? `| ${headers.join(" | ")} |\n| ${separator} |\n` : "";
+		const rows = context.map((item) => `| ${options.fn(item).trim()} |`).join("\n");
+		return headerRow + rows;
+	},
+);
+
+/**
+ * {{#codeblock lang="diff"}}...{{/codeblock}}
+ * Wraps content in a fenced code block.
+ */
+handlebars.registerHelper("codeblock", function (this: unknown, options: Handlebars.HelperOptions): string {
+	const lang = (options.hash.lang as string) ?? "";
+	const content = options.fn(this).trim();
+	return `\`\`\`${lang}\n${content}\n\`\`\``;
+});
+
+/**
+ * {{#xml "tag"}}content{{/xml}}
+ * Wraps content in XML-style tags. Returns empty string if content is empty.
+ */
+handlebars.registerHelper("xml", function (this: unknown, tag: string, options: Handlebars.HelperOptions): string {
+	const content = options.fn(this).trim();
+	if (!content) return "";
+	return `<${tag}>\n${content}\n</${tag}>`;
+});
+
+/**
+ * {{escapeXml value}}
+ * Escapes XML special characters: & < > "
+ */
+handlebars.registerHelper("escapeXml", (value: unknown): string => {
+	if (value == null) return "";
+	return String(value).replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+});
+
+/**
+ * {{len array}}
+ * Returns the length of an array or string.
+ */
+handlebars.registerHelper("len", (value: unknown): number => {
+	if (Array.isArray(value)) return value.length;
+	if (typeof value === "string") return value.length;
+	return 0;
+});
+
+/**
+ * {{add a b}}
+ * Adds two numbers.
+ */
+handlebars.registerHelper("add", (a: number, b: number): number => (a ?? 0) + (b ?? 0));
+
+/**
+ * {{sub a b}}
+ * Subtracts b from a.
+ */
+handlebars.registerHelper("sub", (a: number, b: number): number => (a ?? 0) - (b ?? 0));
+
+/**
+ * {{#has collection item}}...{{else}}...{{/has}}
+ * Checks if an array includes an item or if a Set/Map has a key.
+ */
+handlebars.registerHelper(
+	"has",
+	function (this: unknown, collection: unknown, item: unknown, options: Handlebars.HelperOptions): string {
+		let found = false;
+		if (Array.isArray(collection)) {
+			found = collection.includes(item);
+		} else if (collection instanceof Set) {
+			found = collection.has(item);
+		} else if (collection instanceof Map) {
+			found = collection.has(item);
+		} else if (collection && typeof collection === "object") {
+			if (typeof item === "string" || typeof item === "number" || typeof item === "symbol") {
+				found = item in collection;
+			}
+		}
+		return found ? options.fn(this) : options.inverse(this);
+	},
+);
+
+/**
+ * {{includes array item}}
+ * Returns true if array includes item. For use in other helpers.
+ */
+handlebars.registerHelper("includes", (collection: unknown, item: unknown): boolean => {
+	if (Array.isArray(collection)) return collection.includes(item);
+	if (collection instanceof Set) return collection.has(item);
+	if (collection instanceof Map) return collection.has(item);
+	return false;
+});
+
+/**
+ * {{not value}}
+ * Returns logical NOT of value. For use in subexpressions.
+ */
+handlebars.registerHelper("not", (value: unknown): boolean => !value);
+
+export function renderPromptTemplate(template: string, context: TemplateContext = {}): string {
+	const compiled = handlebars.compile(template, { noEscape: true, strict: false });
+	const rendered = compiled(context ?? {});
+	return optimizePromptLayout(rendered);
+}
+
+function optimizePromptLayout(input: string): string {
+	// 1) strip CR / normalize line endings
+	let s = input.replace(/\r\n?/g, "\n");
+
+	// normalize NBSP -> space
+	s = s.replace(/\u00A0/g, " ");
+
+	const lines = s.split("\n").map((line) => {
+		// 2) remove trailing whitespace (spaces/tabs) per line
+		let l = line.replace(/[ \t]+$/g, "");
+
+		// 3) lines with only whitespace -> empty line
+		if (/^[ \t]*$/.test(l)) return "";
+
+		// 4) normalize leading indentation: every 2 spaces -> \t (preserve leftover 1 space)
+		//    NOTE: This is intentionally *only* leading indentation to avoid mangling prose.
+		const m = l.match(/^[ \t]+/);
+		if (m) {
+			const indent = m[0];
+			const rest = l.slice(indent.length);
+
+			let out = "";
+			let spaces = 0;
+
+			for (const ch of indent) {
+				if (ch === "\t") {
+					// flush pending spaces before existing tab
+					out += "\t".repeat(Math.floor(spaces / 2));
+					if (spaces % 2) out += " ";
+					spaces = 0;
+					out += "\t";
+				} else {
+					spaces++;
+				}
+			}
+
+			out += "\t".repeat(Math.floor(spaces / 2));
+			if (spaces % 2) out += " ";
+
+			l = out + rest;
+		}
+
+		return l;
+	});
+
+	s = lines.join("\n");
+
+	// 5) collapse excessive blank lines
+	s = s.replace(/\n{3,}/g, "\n\n");
+
+	return s.trim();
+}
+
 /**
  * Parse YAML frontmatter from markdown content
  * Returns { frontmatter, content } where content has frontmatter stripped
@@ -235,7 +503,9 @@ export function expandPromptTemplate(text: string, templates: PromptTemplate[]):
 	const template = templates.find((t) => t.name === templateName);
 	if (template) {
 		const args = parseCommandArgs(argsString);
-		return substituteArgs(template.content, args);
+		const argsText = args.join(" ");
+		const substituted = substituteArgs(template.content, args);
+		return renderPromptTemplate(substituted, { args, ARGUMENTS: argsText, arguments: argsText });
 	}
 
 	return text;

package/src/core/sdk.ts

@@ -71,6 +71,7 @@ import { loadSkills as loadSkillsInternal, type Skill, type SkillWarning } from
 import { type FileSlashCommand, loadSlashCommands as loadSlashCommandsInternal } from "./slash-commands";
 import { closeAllConnections } from "./ssh/connection-manager";
 import { unmountAll } from "./ssh/sshfs-mount";
+import { migrateJsonStorage } from "./storage-migration";
 import {
 	buildSystemPrompt as buildSystemPromptInternal,
 	loadProjectContextFiles as loadContextFilesInternal,
@@ -90,7 +91,6 @@ import {
 	createSshTool,
 	createTools,
 	createWriteTool,
-	filterRulebookRules,
 	getWebSearchTools,
 	setPreferredImageProvider,
 	setPreferredWebSearchProvider,
@@ -242,6 +242,13 @@ export async function discoverAuthStorage(agentDir: string = getDefaultAgentDir(
 
 	logger.debug("discoverAuthStorage", { agentDir, primaryPath, allPaths, fallbackPaths });
 
+	// Migrate legacy JSON files (settings.json, auth.json) to SQLite before loading
+	await migrateJsonStorage({
+		agentDir,
+		settingsPath: join(agentDir, "settings.json"),
+		authPaths: [primaryPath, ...fallbackPaths],
+	});
+
 	const storage = new AuthStorage(primaryPath, fallbackPaths);
 	await storage.reload();
 	return storage;
@@ -646,7 +653,12 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 	time("discoverTtsrRules");
 
 	// Filter rules for the rulebook (non-TTSR, non-alwaysApply, with descriptions)
-	const rulebookRules = filterRulebookRules(rulesResult.items);
+	const rulebookRules = rulesResult.items.filter((rule) => {
+		if (rule.ttsrTrigger) return false;
+		if (rule.alwaysApply) return false;
+		if (!rule.description) return false;
+		return true;
+	});
 	time("filterRulebookRules");
 
 	const contextFiles = options.contextFiles ?? discoverContextFiles(cwd, agentDir);
@@ -658,7 +670,6 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 	const toolSession: ToolSession = {
 		cwd,
 		hasUI: options.hasUI ?? false,
-		rulebookRules,
 		eventBus,
 		outputSchema: options.outputSchema,
 		requireCompleteTool: options.requireCompleteTool,