@oh-my-pi/pi-coding-agent 16.0.7 → 16.0.9

package/src/internal-urls/docs-index.ts

@@ -0,0 +1,102 @@
+/**
+ * Harness documentation index for the `omp://` protocol.
+ *
+ * Compiled binaries and the prepacked npm bundle inline a compressed index from
+ * `docs-index.generated.txt` (populated by `scripts/generate-docs-index.ts
+ * --generate` at build time). The format is two lines:
+ *   1. a plain JSON array of the sorted doc file names, and
+ *   2. a base64 gzip blob of the index-aligned doc bodies (`string[]`).
+ * Listing/completion (`getDocFilenames`) parses only the small first line and
+ * never inflates the blob; the bodies are gunzipped off the event loop (via the
+ * async `node:zlib` threadpool) lazily, once, on the first actual read. When the
+ * placeholder is empty (dev tree, source checkout), the index is read from the
+ * repo `docs/` directory on disk instead.
+ */
+import { readFileSync } from "node:fs";
+import * as path from "node:path";
+import { promisify } from "node:util";
+import { gunzip } from "node:zlib";
+import { Glob } from "bun";
+import docsEmbed from "./docs-index.generated.txt";
+
+const gunzipAsync = promisify(gunzip);
+
+export interface DocsIndex {
+	/** Sorted documentation file names, relative to `docs/`. */
+	readonly filenames: readonly string[];
+	/** Resolve a doc body by path; inflates the embedded bodies off-thread, lazily, on first call. */
+	getBody(relativePath: string): Promise<string | undefined>;
+}
+
+/**
+ * Decode a populated two-line embed (`<filenames JSON>\n<base64 gzip of bodies>`)
+ * into a lazily-inflating index, or `null` when there is no newline separator
+ * (the empty placeholder, or a malformed payload — the caller decides which).
+ * Reading `filenames` never touches the blob; the bodies are gunzipped off the
+ * event loop into a path→content table on the first `getBody` call, and that
+ * work is shared across concurrent reads.
+ */
+export function decodeDocsIndex(embed: string): DocsIndex | null {
+	const newline = embed.indexOf("\n");
+	if (newline === -1) return null;
+	const filenames = JSON.parse(embed.slice(0, newline)) as string[];
+	let bodies: Promise<Record<string, string>> | undefined;
+	return {
+		filenames,
+		getBody(relativePath: string): Promise<string | undefined> {
+			bodies ??= (async () => {
+				const inflated = await gunzipAsync(Buffer.from(embed.slice(newline + 1), "base64"));
+				const decoded = JSON.parse(inflated.toString("utf8")) as string[];
+				const map: Record<string, string> = {};
+				for (let i = 0; i < filenames.length; i++) map[filenames[i]] = decoded[i];
+				return map;
+			})();
+			return bodies.then(map => map[relativePath]);
+		},
+	};
+}
+
+/** Dev tree / source checkout: build the index from the repo `docs/` directory. */
+function readDocsFromDisk(): DocsIndex {
+	const docsDir = path.resolve(import.meta.dir, "../../../../docs");
+	const filenames: string[] = [];
+	const bodies: Record<string, string> = {};
+	for (const relativePath of new Glob("**/*.md").scanSync(docsDir)) {
+		const normalized = relativePath.split(path.sep).join("/");
+		filenames.push(normalized);
+		bodies[normalized] = readFileSync(path.join(docsDir, relativePath), "utf8");
+	}
+	filenames.sort();
+	return { filenames, getBody: relativePath => Promise.resolve(bodies[relativePath]) };
+}
+
+let index: DocsIndex | undefined;
+function getIndex(): DocsIndex {
+	if (index !== undefined) return index;
+	// Empty placeholder → dev tree / source checkout: read docs from disk.
+	if (docsEmbed.length === 0) {
+		index = readDocsFromDisk();
+		return index;
+	}
+	// Populated embed in compiled binaries / npm bundle. A non-empty payload with
+	// no newline is a broken build (truncated/corrupt embed), not a placeholder.
+	const decoded = decodeDocsIndex(docsEmbed);
+	if (decoded === null) {
+		throw new Error(
+			"Malformed embedded docs index (docs-index.generated.txt): non-empty payload without a newline separator. " +
+				"Rebuild with `bun --cwd=packages/coding-agent scripts/generate-docs-index.ts --generate`.",
+		);
+	}
+	index = decoded;
+	return index;
+}
+
+/** Sorted list of available documentation file names (relative to `docs/`). */
+export function getDocFilenames(): readonly string[] {
+	return getIndex().filenames;
+}
+
+/** Resolve a documentation file's content, or `undefined` when not found. */
+export function getEmbeddedDoc(relativePath: string): Promise<string | undefined> {
+	return getIndex().getBody(relativePath);
+}

package/src/internal-urls/omp-protocol.ts

@@ -8,7 +8,7 @@
  * - omp://<file>.md - Reads a specific documentation file
  */
 import * as path from "node:path";
-import { EMBEDDED_DOC_FILENAMES, EMBEDDED_DOCS } from "./docs-index.generated";
+import { getDocFilenames, getEmbeddedDoc } from "./docs-index";
 import type { InternalResource, InternalUrl, ProtocolHandler, UrlCompletion } from "./types";
 
 /**
@@ -34,16 +34,17 @@ export class OmpProtocolHandler implements ProtocolHandler {
 	}
 
 	async complete(): Promise<UrlCompletion[]> {
-		return EMBEDDED_DOC_FILENAMES.map(value => ({ value }));
+		return getDocFilenames().map(value => ({ value }));
 	}
 
 	async #listDocs(url: InternalUrl): Promise<InternalResource> {
-		if (EMBEDDED_DOC_FILENAMES.length === 0) {
+		const filenames = getDocFilenames();
+		if (filenames.length === 0) {
 			throw new Error("No documentation files found");
 		}
 
-		const listing = EMBEDDED_DOC_FILENAMES.map(f => `- [${f}](omp://${f})`).join("\n");
-		const content = `# Documentation\n\n${EMBEDDED_DOC_FILENAMES.length} files available:\n\n${listing}\n`;
+		const listing = filenames.map(f => `- [${f}](omp://${f})`).join("\n");
+		const content = `# Documentation\n\n${filenames.length} files available:\n\n${listing}\n`;
 
 		return {
 			url: url.href,
@@ -70,12 +71,12 @@ export class OmpProtocolHandler implements ProtocolHandler {
 			return this.#listDocs(url);
 		}
 
-		const content = EMBEDDED_DOCS[docPath];
+		const content = await getEmbeddedDoc(docPath);
 		if (content === undefined) {
 			const lookup = docPath.replace(/\.md$/, "");
-			const suggestions = EMBEDDED_DOC_FILENAMES.filter(
-				f => f.includes(lookup) || lookup.includes(f.replace(/\.md$/, "")),
-			).slice(0, 5);
+			const suggestions = getDocFilenames()
+				.filter(f => f.includes(lookup) || lookup.includes(f.replace(/\.md$/, "")))
+				.slice(0, 5);
 			const suffix =
 				suggestions.length > 0
 					? `\nDid you mean: ${suggestions.join(", ")}`

package/src/main.ts

@@ -1039,6 +1039,13 @@ export async function runRootCommand(
 		});
 	}
 
+	// --print-thoughts (single-shot print mode) must surface reasoning, so un-hide
+	// thinking before the session is built — otherwise a passive hideThinkingBlock
+	// setting makes the provider omit summaries and the flag prints nothing. An
+	// explicit --hide-thinking below still wins.
+	if (parsedArgs.printThoughts && !isProtocolMode && !isInteractive) {
+		settingsInstance.override("hideThinkingBlock", false);
+	}
 	// Apply --hide-thinking CLI flag (ephemeral, not persisted)
 	if (parsedArgs.hideThinking) {
 		settingsInstance.override("hideThinkingBlock", true);
@@ -1373,6 +1380,7 @@ export async function runRootCommand(
 				messages: initialArgs.messages,
 				initialMessage,
 				initialImages,
+				printThoughts: initialArgs.printThoughts,
 			});
 			if ($env.PI_TIMING) {
 				logger.printTimings();

package/src/markit/NOTICE

@@ -0,0 +1,32 @@
+This directory contains an in-house document-to-markdown engine adapted from
+markit-ai (https://github.com/Michaelliv/markit), used under the MIT License.
+
+  Copyright (c) 2026 Michael Liv
+
+Only the converters for the document formats omp supports are ported (pdf,
+docx, pptx, xlsx, epub); the CLI, plugin/provider, and unused converters
+(html, image, audio, plain-text, rss, github, wikipedia, csv, json, yaml,
+ipynb, iwork, zip, xml) were dropped. Legacy binary `.doc`/`.ppt`/`.xls` and
+`.rtf` are routed by the read/fetch tools but have no converter — they surface
+a conversion error, exactly as upstream markit did. Logic is ported faithfully
+so conversion output matches the upstream package.
+
+MIT License
+
+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/src/markit/converters/docx.ts

@@ -0,0 +1,56 @@
+// Adapted from markit-ai (MIT). See ../NOTICE.
+import * as path from "node:path";
+import mammoth from "mammoth";
+import { createTurndown, normalizeTablesHtml } from "../../utils/turndown";
+import type { ConversionResult, Converter, StreamInfo } from "../types";
+
+const EXTENSIONS = [".docx"];
+const MIMETYPES = ["application/vnd.openxmlformats-officedocument.wordprocessingml.document"];
+
+export class DocxConverter implements Converter {
+	name = "docx";
+
+	accepts(streamInfo: StreamInfo): boolean {
+		if (streamInfo.extension && EXTENSIONS.includes(streamInfo.extension)) {
+			return true;
+		}
+		if (streamInfo.mimetype && MIMETYPES.some(m => streamInfo.mimetype?.startsWith(m))) {
+			return true;
+		}
+		return false;
+	}
+
+	async convert(input: Buffer, streamInfo: StreamInfo): Promise<ConversionResult> {
+		const imageDir = streamInfo.imageDir;
+		let imageCount = 0;
+		const convertImage = imageDir
+			? mammoth.images.imgElement(image => {
+					imageCount++;
+					const ext = (image.contentType?.split("/")[1] || "png").replace("jpeg", "jpg");
+					const filename = `image_${imageCount}.${ext}`;
+					const filepath = path.join(imageDir, filename);
+					return image.read("base64").then(async base64 => {
+						await Bun.write(filepath, Buffer.from(base64, "base64"));
+						return { src: filepath, alt: `image_${imageCount}` };
+					});
+				})
+			: mammoth.images.imgElement(image => {
+					imageCount++;
+					const contentType = image.contentType || "image/png";
+					return image.read("base64").then(base64 => {
+						return {
+							src: `data:${contentType};base64,${base64.slice(0, 0)}`,
+							alt: `image_${imageCount}`,
+						};
+					});
+				});
+		const { value: html } = await mammoth.convertToHtml({ buffer: input }, { convertImage });
+		const turndown = createTurndown();
+		let markdown = turndown.turndown(normalizeTablesHtml(html));
+		// Replace data URI images with comment placeholders when no imageDir
+		if (!imageDir) {
+			markdown = markdown.replace(/!\[([^\]]*)\]\(data:[^)]*\)/g, "<!-- image: $1 -->");
+		}
+		return { markdown: markdown.trim() };
+	}
+}

package/src/markit/converters/epub.ts

@@ -0,0 +1,136 @@
+// Adapted from markit-ai (MIT). See ../NOTICE.
+import { XMLParser } from "fast-xml-parser";
+import { createTurndown, normalizeTablesHtml } from "../../utils/turndown";
+import { unzip, unzipText } from "../../utils/zip";
+import type { ConversionResult, Converter, StreamInfo } from "../types";
+
+const EXTENSIONS = [".epub"];
+const MIMETYPES = ["application/epub", "application/epub+zip", "application/x-epub+zip"];
+
+/** A metadata value: a bare string, or a node carrying `#text` and/or array children. */
+type MetaValue = string | MetaNode;
+interface MetaNode {
+	"#text"?: string;
+	[index: number]: MetaValue;
+}
+interface Metadata {
+	"dc:title"?: MetaValue;
+	"dc:creator"?: MetaValue;
+	"dc:language"?: MetaValue;
+	"dc:publisher"?: MetaValue;
+	"dc:date"?: MetaValue;
+	"dc:description"?: MetaValue;
+}
+interface ManifestItem {
+	"@_id": string;
+	"@_href": string;
+}
+interface SpineItem {
+	"@_idref": string;
+}
+interface OpfDoc {
+	package?: {
+		metadata?: Metadata;
+		manifest?: { item?: ManifestItem | ManifestItem[] };
+		spine?: { itemref?: SpineItem | SpineItem[] };
+	};
+}
+interface Rootfile {
+	"@_full-path": string;
+}
+interface ContainerDoc {
+	container?: { rootfiles?: { rootfile?: Rootfile | Rootfile[] } };
+}
+
+export class EpubConverter implements Converter {
+	name = "epub";
+
+	accepts(streamInfo: StreamInfo): boolean {
+		if (streamInfo.extension && EXTENSIONS.includes(streamInfo.extension)) return true;
+		if (streamInfo.mimetype && MIMETYPES.some(m => streamInfo.mimetype?.startsWith(m))) return true;
+		return false;
+	}
+
+	async convert(input: Buffer, _streamInfo: StreamInfo): Promise<ConversionResult> {
+		const entries = unzip(input);
+		const parser = new XMLParser({
+			ignoreAttributes: false,
+			attributeNamePrefix: "@_",
+			textNodeName: "#text",
+			processEntities: { maxTotalExpansions: 1_000_000 },
+		});
+		// Find content.opf path from container.xml
+		const containerXml = unzipText(entries, "META-INF/container.xml");
+		if (!containerXml) throw new Error("Invalid EPUB: missing container.xml");
+		const container = parser.parse(containerXml) as ContainerDoc;
+		const rootfile = container.container?.rootfiles?.rootfile;
+		const opfPath = Array.isArray(rootfile) ? rootfile[0]["@_full-path"] : rootfile?.["@_full-path"];
+		if (!opfPath) throw new Error("Invalid EPUB: missing rootfile path");
+		// Parse content.opf
+		const opfXml = unzipText(entries, opfPath);
+		if (!opfXml) throw new Error("Invalid EPUB: missing content.opf");
+		const opf = parser.parse(opfXml) as OpfDoc;
+		// Extract metadata
+		const meta: Metadata = opf.package?.metadata ?? {};
+		const metadata: Record<string, string | undefined> = {
+			title: this.getText(meta["dc:title"]),
+			authors: this.getTextArray(meta["dc:creator"]).join(", ") || undefined,
+			language: this.getText(meta["dc:language"]),
+			publisher: this.getText(meta["dc:publisher"]),
+			date: this.getText(meta["dc:date"]),
+			description: this.getText(meta["dc:description"]),
+		};
+		// Build manifest map (id → href)
+		const manifestItems = opf.package?.manifest?.item;
+		const itemList = Array.isArray(manifestItems) ? manifestItems : manifestItems ? [manifestItems] : [];
+		const manifest = new Map<string, string>();
+		for (const item of itemList) {
+			manifest.set(item["@_id"], item["@_href"]);
+		}
+		// Get spine order
+		const spineItems = opf.package?.spine?.itemref;
+		const spineList = Array.isArray(spineItems) ? spineItems : spineItems ? [spineItems] : [];
+		const spineOrder = spineList.map(s => s["@_idref"]);
+		// Resolve file paths
+		const basePath = opfPath.includes("/") ? opfPath.substring(0, opfPath.lastIndexOf("/")) : "";
+		const turndown = createTurndown();
+		const sections: string[] = [];
+		// Add metadata header
+		const metaLines: string[] = [];
+		for (const key in metadata) {
+			const value = metadata[key];
+			if (value) metaLines.push(`**${key.charAt(0).toUpperCase() + key.slice(1)}:** ${value}`);
+		}
+		if (metaLines.length > 0) sections.push(metaLines.join("\n"));
+		// Convert spine files
+		for (const idref of spineOrder) {
+			const href = manifest.get(idref);
+			if (!href) continue;
+			const filePath = basePath ? `${basePath}/${href}` : href;
+			const html = unzipText(entries, filePath);
+			if (!html) continue;
+			// Strip script/style, convert to markdown
+			const cleaned = html.replace(/<script[\s\S]*?<\/script>/gi, "").replace(/<style[\s\S]*?<\/style>/gi, "");
+			const md = turndown.turndown(normalizeTablesHtml(cleaned)).trim();
+			if (md) sections.push(md);
+		}
+		return {
+			markdown: sections.join("\n\n").trim(),
+			title: metadata.title,
+		};
+	}
+
+	getText(node: MetaValue | undefined): string | undefined {
+		if (!node) return undefined;
+		if (typeof node === "string") return node;
+		if (node["#text"]) return String(node["#text"]);
+		if (Array.isArray(node)) return this.getText(node[0]);
+		return undefined;
+	}
+
+	getTextArray(node: MetaValue | undefined): (string | undefined)[] {
+		if (!node) return [];
+		const list = Array.isArray(node) ? node : [node];
+		return list.map(n => this.getText(n)).filter(Boolean);
+	}
+}

package/src/markit/converters/mammoth.d.ts

@@ -0,0 +1,24 @@
+// Minimal ambient types for `mammoth` (ships no types). Declares only what
+// DocxConverter uses. See ../NOTICE.
+declare module "mammoth" {
+	interface MammothImage {
+		contentType?: string;
+		read(encoding: "base64"): Promise<string>;
+	}
+	interface ImgAttributes {
+		src: string;
+		alt?: string;
+	}
+	type ConvertImageHandler = (image: MammothImage) => Promise<ImgAttributes>;
+	interface ConvertOptions {
+		convertImage?: ConvertImageHandler;
+	}
+	interface ConvertResult {
+		value: string;
+		messages: unknown[];
+	}
+	export const images: { imgElement(fn: ConvertImageHandler): ConvertImageHandler };
+	export function convertToHtml(input: { buffer: Buffer }, options?: ConvertOptions): Promise<ConvertResult>;
+	const _default: { convertToHtml: typeof convertToHtml; images: typeof images };
+	export default _default;
+}

package/src/markit/converters/pdf/columns.ts

@@ -0,0 +1,103 @@
+// Adapted from markit-ai (MIT). See ../../NOTICE.
+
+/**
+ * Multi-column layout detection and text box reordering.
+ *
+ * Many PDFs (legal documents, datasheets, academic papers) use two-column
+ * layouts. Without column detection, text boxes are ordered by Y position
+ * only, interleaving left and right column content.
+ *
+ * Algorithm:
+ *   1. Collect left edges of all text boxes on the page
+ *   2. Find the largest horizontal gap between consecutive left edges
+ *   3. If gap > MIN_GAP_RATIO of the text width and both sides have
+ *      enough boxes → multi-column detected
+ *   4. Assign each text box to a column based on its center X
+ *   5. Return columns in reading order (left-to-right, top-to-bottom)
+ *
+ * This only detects the column structure. The caller is responsible for
+ * processing each column's text boxes independently (table detection,
+ * rendering, etc.).
+ */
+import type { TextBox } from "./types";
+
+export interface ColumnLayout {
+	/** Number of columns detected (1 = single column, 2+ = multi-column). */
+	columnCount: number;
+	/** Text boxes grouped by column, in reading order (left to right). */
+	columns: TextBox[][];
+	/** X positions of column boundaries (between columns). */
+	boundaries: number[];
+}
+
+/**
+ * Minimum gap as a fraction of the total text width to consider a column
+ * boundary. A two-column layout typically has ~50% gap; we use a lower
+ * threshold to catch asymmetric columns.
+ */
+const MIN_GAP_RATIO = 0.15;
+/** Minimum number of text boxes on each side of the gap. */
+const MIN_BOXES_PER_COLUMN = 4;
+/** Minimum gap in absolute points to avoid splitting on small whitespace. */
+const MIN_GAP_PTS = 40;
+
+/**
+ * Detect column layout and return text boxes grouped by column.
+ *
+ * For single-column pages, returns all boxes in one group.
+ * For multi-column pages, returns boxes split by column in reading order.
+ */
+export function detectColumns(textBoxes: TextBox[]): ColumnLayout {
+	if (textBoxes.length < MIN_BOXES_PER_COLUMN * 2) {
+		return { columnCount: 1, columns: [textBoxes], boundaries: [] };
+	}
+	// Collect unique left edges (rounded to avoid float noise)
+	const lefts = [...new Set(textBoxes.map(tb => Math.round(tb.bounds.left)))].sort((a, b) => a - b);
+	if (lefts.length < 2) {
+		return { columnCount: 1, columns: [textBoxes], boundaries: [] };
+	}
+	const textXMin = lefts[0];
+	const textXMax = Math.max(...textBoxes.map(tb => Math.round(tb.bounds.right)));
+	const textWidth = textXMax - textXMin;
+	if (textWidth <= 0) {
+		return { columnCount: 1, columns: [textBoxes], boundaries: [] };
+	}
+	// Find the largest gap between consecutive left-edge positions
+	let maxGap = 0;
+	let gapLeft = 0;
+	let gapRight = 0;
+	for (let i = 1; i < lefts.length; i++) {
+		const gap = lefts[i] - lefts[i - 1];
+		if (gap > maxGap) {
+			maxGap = gap;
+			gapLeft = lefts[i - 1];
+			gapRight = lefts[i];
+		}
+	}
+	const gapRatio = maxGap / textWidth;
+	if (gapRatio < MIN_GAP_RATIO || maxGap < MIN_GAP_PTS) {
+		return { columnCount: 1, columns: [textBoxes], boundaries: [] };
+	}
+	// Split point is the midpoint of the gap
+	const splitX = (gapLeft + gapRight) / 2;
+	// Assign boxes to columns based on center X
+	const leftCol: TextBox[] = [];
+	const rightCol: TextBox[] = [];
+	for (const tb of textBoxes) {
+		const cx = (tb.bounds.left + tb.bounds.right) / 2;
+		if (cx < splitX) {
+			leftCol.push(tb);
+		} else {
+			rightCol.push(tb);
+		}
+	}
+	// Validate both columns have enough content
+	if (leftCol.length < MIN_BOXES_PER_COLUMN || rightCol.length < MIN_BOXES_PER_COLUMN) {
+		return { columnCount: 1, columns: [textBoxes], boundaries: [] };
+	}
+	return {
+		columnCount: 2,
+		columns: [leftCol, rightCol],
+		boundaries: [splitX],
+	};
+}