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

package/dist/types/cli/update-cli.d.ts

@@ -27,6 +27,17 @@ interface UpdateMethodResolutionOptions {
     miseDataDir?: string;
 }
 export declare function resolveUpdateMethodForTest(ompPath: string, bunBinDir: string | undefined, options?: UpdateMethodResolutionOptions): UpdateMethod;
+/**
+ * Best-effort removal of binary-update backups left by earlier runs.
+ *
+ * Each self-update moves the previous executable to `<binary>.<timestamp>.<pid>.bak`
+ * before swapping the new one in. On Windows that backup cannot be deleted
+ * while the updating process is alive, so it is left for a later run to reclaim
+ * once its owning process has exited. Also matches the legacy fixed
+ * `<binary>.bak` name produced before backups were timestamped, so users
+ * upgrading from a buggy release get the orphaned file cleaned up.
+ */
+export declare function sweepStaleBackups(targetPath: string): Promise<void>;
 /**
  * Atomically replace the installed binary and roll back if version verification fails.
  */

package/dist/types/debug/remote-debugger.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Bun JavaScriptCore remote inspector control.
+ *
+ * Wraps `bun:jsc`'s `startRemoteDebugger`, which exposes JavaScriptCore's
+ * built-in WebKit RemoteInspectorServer over a raw socket. The API is one-shot
+ * and rough around the edges (Bun documents it as untested, "may not be
+ * supported yet on macOS"):
+ *   - it returns `void` and has no stop handle, so we track the live endpoint
+ *     at module scope and make starting idempotent;
+ *   - it rejects port `0`, so "let the OS pick" is implemented by reserving a
+ *     free port via `node:net` and handing the concrete number to Bun;
+ *   - on macOS (Bun 1.3.x) it throws a spurious "port already in use" error
+ *     even when the server binds fine, so success is decided by a loopback
+ *     probe rather than by whether the call threw.
+ */
+export interface RemoteDebuggerInfo {
+    host: string;
+    port: number;
+}
+/** Underlying starter signature; tests inject a disposable listener in its place. */
+export type RemoteDebuggerStarter = (host: string, port: number) => void;
+export interface StartRemoteDebuggerOptions {
+    /** Explicit port; when omitted a free port is reserved automatically. */
+    port?: number;
+    /** Override the JSC starter. Defaults to `bun:jsc`'s `startRemoteDebugger`. */
+    start?: RemoteDebuggerStarter;
+}
+/** The live inspector endpoint for this process, or `null` if not started. */
+export declare function getRemoteDebugger(): RemoteDebuggerInfo | null;
+/**
+ * Start the JavaScriptCore remote inspector for this process and return its
+ * endpoint. Idempotent: the underlying API cannot be stopped or rebound, so a
+ * second call returns the existing endpoint instead of starting again. When
+ * `port` is omitted a free port is reserved automatically.
+ *
+ * Throws only when the socket never comes up; Bun's spurious bind error is
+ * swallowed and overridden by the loopback probe.
+ */
+export declare function startRemoteDebuggerServer(options?: StartRemoteDebuggerOptions): Promise<RemoteDebuggerInfo>;
+/**
+ * Test-only: forget the tracked endpoint so a fresh start can be exercised.
+ * Does not (and cannot) stop a real JSC inspector — callers in tests own the
+ * disposable listener they injected.
+ */
+export declare function __resetRemoteDebuggerForTests(): void;

package/dist/types/internal-urls/docs-index.d.ts

@@ -0,0 +1,19 @@
+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 declare function decodeDocsIndex(embed: string): DocsIndex | null;
+/** Sorted list of available documentation file names (relative to `docs/`). */
+export declare function getDocFilenames(): readonly string[];
+/** Resolve a documentation file's content, or `undefined` when not found. */
+export declare function getEmbeddedDoc(relativePath: string): Promise<string | undefined>;

package/dist/types/markit/converters/docx.d.ts

@@ -0,0 +1,6 @@
+import type { ConversionResult, Converter, StreamInfo } from "../types";
+export declare class DocxConverter implements Converter {
+    name: string;
+    accepts(streamInfo: StreamInfo): boolean;
+    convert(input: Buffer, streamInfo: StreamInfo): Promise<ConversionResult>;
+}

package/dist/types/markit/converters/epub.d.ts

@@ -0,0 +1,15 @@
+import type { ConversionResult, Converter, StreamInfo } from "../types";
+/** 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;
+}
+export declare class EpubConverter implements Converter {
+    name: string;
+    accepts(streamInfo: StreamInfo): boolean;
+    convert(input: Buffer, _streamInfo: StreamInfo): Promise<ConversionResult>;
+    getText(node: MetaValue | undefined): string | undefined;
+    getTextArray(node: MetaValue | undefined): (string | undefined)[];
+}
+export {};

package/dist/types/markit/converters/pdf/columns.d.ts

@@ -0,0 +1,35 @@
+/**
+ * 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[];
+}
+/**
+ * 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 declare function detectColumns(textBoxes: TextBox[]): ColumnLayout;

package/dist/types/markit/converters/pdf/extract.d.ts

@@ -0,0 +1,10 @@
+import type { ImageRegion, PageContent } from "./types";
+/**
+ * Render an image region from a PDF page as a PNG buffer.
+ * Uses mupdf's DrawDevice to render just the cropped area at 2x resolution.
+ */
+export declare function renderImageRegion(input: Uint8Array, region: ImageRegion): Promise<Uint8Array>;
+/**
+ * Extract text boxes and vector segments from all pages of a PDF buffer.
+ */
+export declare function extractPages(input: Uint8Array): Promise<PageContent[]>;

package/dist/types/markit/converters/pdf/grid.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Table grid detection from vector segments and text boxes.
+ *
+ * Ported from @oharato/pdf2md-ts with TypeScript types and without
+ * CJK-specific borderless table heuristics. The core algorithm:
+ *
+ * 1. Classify segments as horizontal or vertical lines
+ * 2. Group horizontal Y-lines into table groups (split by vertical gaps)
+ * 3. For each group:
+ *    a. Full grid (H+V lines): build cells from grid intersections,
+ *       place text via raycasting
+ *    b. H-line only (no V lines): infer columns from text X positions
+ * 4. Prune empty rows/cols
+ *
+ * Coordinate system: PDF native (bottom-left origin, Y increases upward).
+ */
+import type { Segment, TableGrid, TextBox } from "./types";
+export interface GridResult {
+    grids: TableGrid[];
+    consumedIds: string[];
+}
+/**
+ * Detect all table grids on a single page from its text boxes and segments.
+ */
+export declare function resolveTableGrids(pageNumber: number, textBoxes: TextBox[], segments: Segment[]): GridResult;

package/dist/types/markit/converters/pdf/headers.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Running header/footer detection and removal.
+ *
+ * Many PDFs have repeated text at the top or bottom of every page:
+ * document titles, chapter names, page numbers, copyright notices.
+ * These pollute the markdown output as false headings or noise.
+ *
+ * Algorithm:
+ *   1. For each page, bucket text boxes by Y position (top/bottom zones)
+ *   2. Collect the text content at each zone across all pages
+ *   3. Text appearing on >20% of pages OR 8+ consecutive pages is a
+ *      running header/footer
+ *   4. Remove matching text boxes before further processing
+ */
+import type { PageContent } from "./types";
+/**
+ * Detect and remove running headers and footers from all pages.
+ * Mutates the pages array in place, removing header/footer text boxes.
+ *
+ * Uses two strategies:
+ *   1. Global frequency: text appearing on > 20% of all pages
+ *   2. Consecutive runs: text appearing on 8+ consecutive pages
+ */
+export declare function stripHeadersFooters(pages: PageContent[]): void;

package/dist/types/markit/converters/pdf/index.d.ts

@@ -0,0 +1,6 @@
+import type { ConversionResult, Converter, StreamInfo } from "../../types";
+export declare class PdfConverter implements Converter {
+    name: string;
+    accepts(streamInfo: StreamInfo): boolean;
+    convert(input: Buffer, streamInfo: StreamInfo): Promise<ConversionResult>;
+}

package/dist/types/markit/converters/pdf/render.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Markdown rendering for PDF pages.
+ *
+ * Converts table grids and free text boxes into markdown, handling:
+ * - Table grid → markdown table (`| col | col |`)
+ * - Free text → paragraphs with heading detection (by font size)
+ * - Content ordering (top-to-bottom via Y coordinate)
+ * - Paragraph wrap merging (lines broken across PDF line boundaries)
+ * - Page number removal
+ *
+ * Ported from @oharato/pdf2md-ts, stripped of CJK/TDnet-specific logic.
+ */
+import type { TableGrid, TextBox } from "./types";
+/**
+ * Render a TableGrid as a markdown table.
+ */
+export declare function renderTableToMarkdown(table: TableGrid): string;
+/**
+ * Render one page's content: free text and tables interleaved top-to-bottom.
+ */
+export declare function renderPageContent(freeTextBoxes: TextBox[], tables: TableGrid[], imageBlocks?: Array<{
+    topY: number;
+    markdown: string;
+}>, allTextBoxes?: TextBox[]): string;

package/dist/types/markit/converters/pdf/types.d.ts

@@ -0,0 +1,75 @@
+/** Bounding box in PDF coordinate space (origin = bottom-left). */
+export type Bounds = {
+    left: number;
+    right: number;
+    /** Higher value = higher on the page. */
+    top: number;
+    bottom: number;
+};
+/** A text fragment with position and font metadata. */
+export type TextBox = {
+    id: string;
+    text: string;
+    bounds: Bounds;
+    pageNumber: number;
+    /** Dominant font size in points. */
+    fontSize: number;
+    /** True if rendered bold (font name or rendering mode). */
+    isBold: boolean;
+};
+/** A horizontal or vertical line segment extracted from vector graphics. */
+export type Segment = {
+    id: string;
+    x1: number;
+    y1: number;
+    x2: number;
+    y2: number;
+};
+/** A single cell in a resolved table grid. */
+export type TableCell = {
+    row: number;
+    col: number;
+    text: string;
+    rowSpan: number;
+    colSpan: number;
+};
+/** A resolved table grid ready for markdown rendering. */
+export type TableGrid = {
+    pageNumber: number;
+    rows: number;
+    cols: number;
+    cells: TableCell[];
+    warnings: string[];
+    /** Top Y coordinate (PDF space: larger = higher on page). */
+    topY: number;
+    /** True for tables detected without vector borders. */
+    isBorderless: boolean;
+};
+/** An image/diagram region detected on a page. */
+export type ImageRegion = {
+    id: string;
+    pageNumber: number;
+    /** Bounding box in mupdf coordinates (top-left origin). */
+    bbox: {
+        x: number;
+        y: number;
+        w: number;
+        h: number;
+    };
+    /** Y position in PDF coordinates (bottom-left) for ordering. */
+    topY: number;
+};
+/** Result of extracting content from a single PDF page. */
+export type PageContent = {
+    pageNumber: number;
+    textBoxes: TextBox[];
+    segments: Segment[];
+    images: ImageRegion[];
+};
+/** A block of rendered content (text paragraph or table). */
+export type ContentBlock = {
+    topY: number;
+    content: string;
+    /** True if this line has wide gaps between text boxes (column headers). */
+    isTabular?: boolean;
+};

package/dist/types/markit/converters/pptx.d.ts

@@ -0,0 +1,57 @@
+import type { ConversionResult, Converter, StreamInfo } from "../types";
+/** A text value: bare string/number, or a `{ "#text" }` node when the element carries attributes. */
+type XmlText = string | number | {
+    "#text"?: string;
+};
+interface TextRun {
+    "a:t"?: XmlText;
+}
+interface Paragraph {
+    "a:r"?: TextRun | TextRun[];
+}
+interface TextBody {
+    "a:p"?: Paragraph | Paragraph[];
+}
+interface CNvPr {
+    "@_name": string;
+}
+interface Placeholder {
+    "@_type": string;
+}
+interface NvPr {
+    "p:ph"?: Placeholder;
+}
+interface NvSpPr {
+    "p:cNvPr"?: CNvPr;
+    "p:nvPr"?: NvPr;
+}
+interface Shape {
+    "p:txBody"?: TextBody;
+    "p:nvSpPr"?: NvSpPr;
+}
+interface TableCell {
+    "a:txBody"?: TextBody;
+}
+interface TableRow {
+    "a:tc"?: TableCell | TableCell[];
+}
+interface Table {
+    "a:tr"?: TableRow | TableRow[];
+}
+interface GraphicData {
+    "a:tbl"?: Table;
+}
+interface Graphic {
+    "a:graphicData"?: GraphicData;
+}
+interface GraphicFrame {
+    "a:graphic"?: Graphic;
+}
+export declare class PptxConverter implements Converter {
+    name: string;
+    accepts(streamInfo: StreamInfo): boolean;
+    convert(input: Buffer, streamInfo: StreamInfo): Promise<ConversionResult>;
+    extractText(shape: Shape): string;
+    extractTable(gf: GraphicFrame): string | null;
+}
+export {};

package/dist/types/markit/converters/xlsx.d.ts

@@ -0,0 +1,25 @@
+import type { ConversionResult, Converter, StreamInfo } from "../types";
+/** A text value: bare string/number, or a `{ "#text" }` node when the element carries attributes. */
+type XmlText = string | number | {
+    "#text"?: string;
+};
+interface RichTextRun {
+    t?: XmlText;
+}
+interface StringItem {
+    t?: XmlText;
+    r?: RichTextRun | RichTextRun[];
+}
+interface Cell {
+    "@_t"?: string;
+    v?: string | number;
+    is?: StringItem;
+}
+export declare class XlsxConverter implements Converter {
+    name: string;
+    accepts(streamInfo: StreamInfo): boolean;
+    convert(input: Buffer, _streamInfo: StreamInfo): Promise<ConversionResult>;
+    getCellValue(cell: Cell, shared: StringItem[]): string;
+    getSharedString(shared: StringItem[], idx: number): string;
+}
+export {};

package/dist/types/markit/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./registry";
+export * from "./types";

package/dist/types/markit/registry.d.ts

@@ -0,0 +1,16 @@
+import type { ConversionResult, MarkitOptions, StreamInfo } from "./types";
+/**
+ * In-house document → markdown engine (replaces the `markit-ai` package).
+ *
+ * Only the document converters omp routes are registered (pdf, docx, pptx,
+ * xlsx, epub). The first converter whose `accepts()` returns true and whose
+ * `convert()` succeeds wins.
+ */
+export declare class Markit {
+    #private;
+    constructor(options?: MarkitOptions);
+    convertFile(filePath: string, extra?: {
+        imageDir?: string;
+    }): Promise<ConversionResult>;
+    convert(input: Buffer, streamInfo: StreamInfo): Promise<ConversionResult>;
+}

package/dist/types/markit/types.d.ts

@@ -0,0 +1,30 @@
+export interface StreamInfo {
+    mimetype?: string;
+    extension?: string;
+    charset?: string;
+    filename?: string;
+    localPath?: string;
+    url?: string;
+    /** Directory to write extracted images/diagrams. */
+    imageDir?: string;
+}
+export interface ConversionResult {
+    markdown: string;
+    title?: string;
+}
+export interface MarkitOptions {
+    /** Describe an image, return markdown. Receives raw bytes and mimetype. */
+    describe?: (image: Buffer, mimetype: string) => Promise<string>;
+    /** Transcribe audio, return text. Receives raw bytes and mimetype. */
+    transcribe?: (audio: Buffer, mimetype: string) => Promise<string>;
+    /** Extra instructions appended to the image description prompt. */
+    prompt?: string;
+}
+export interface Converter {
+    /** Human-readable name for error messages. */
+    name: string;
+    /** Quick check: can this converter handle the given stream? */
+    accepts(streamInfo: StreamInfo): boolean;
+    /** Convert the source to markdown. */
+    convert(input: Buffer, streamInfo: StreamInfo, options?: MarkitOptions): Promise<ConversionResult>;
+}

package/dist/types/session/agent-session.d.ts

@@ -397,18 +397,17 @@ export declare class AgentSession {
     get obfuscator(): SecretObfuscator | undefined;
     /** Whether a TTSR abort is pending (stream was aborted to inject rules) */
     get isTtsrAbortPending(): boolean;
-    /** Whether the plan-mode → compaction transition's expected internal abort is
-     *  pending. Consumed by `#handleAgentEvent` to stamp `SILENT_ABORT_MARKER`
-     *  on the next aborted assistant message_end; cleared unconditionally by
-     *  `InteractiveMode.#approvePlan`'s `finally` block. */
-    get isPlanCompactAbortPending(): boolean;
+    /** Whether an expected internal plan-mode abort is pending. Consumed by
+     *  `#handleAgentEvent` to stamp `SILENT_ABORT_MARKER` on the next aborted
+     *  assistant message_end; callers clear it in `finally`. */
+    get isPlanInternalAbortPending(): boolean;
     /** Arm the silent-abort marker for the next aborted assistant message_end.
-     *  Caller MUST clear via `clearPlanCompactAbortPending()` in a `finally`
+     *  Caller MUST clear via `clearPlanInternalAbortPending()` in a `finally`
      *  to guarantee no leak. */
-    markPlanCompactAbortPending(): void;
+    markPlanInternalAbortPending(): void;
     /** Unconditionally clear the silent-abort flag. Idempotent: safe when the
      *  flag was never set OR was already consumed by `#handleAgentEvent`. */
-    clearPlanCompactAbortPending(): void;
+    clearPlanInternalAbortPending(): void;
     getAsyncJobSnapshot(options?: {
         recentLimit?: number;
     }): AsyncJobSnapshot | null;

package/dist/types/session/auth-storage.d.ts

@@ -2,5 +2,6 @@
  * Re-exports from @oh-my-pi/pi-ai.
  * All credential storage types and the AuthStorage class now live in the ai package.
  */
-export type { ApiKeyCredential, AuthCredential, AuthCredentialEntry, AuthCredentialStore, AuthStorageData, AuthStorageOptions, CredentialOrigin, CredentialOriginKind, OAuthAccountIdentity, OAuthCredential, ResetCreditAccountStatus, ResetCreditRedeemOutcome, ResetCreditTarget, SerializedAuthStorage, SnapshotResponse, StoredAuthCredential, } from "@oh-my-pi/pi-ai";
-export { AuthBrokerClient, AuthStorage, DEFAULT_SNAPSHOT_CACHE_TTL_MS, REMOTE_REFRESH_SENTINEL, RemoteAuthCredentialStore, readAuthBrokerSnapshotCache, SqliteAuthCredentialStore, writeAuthBrokerSnapshotCache, } from "@oh-my-pi/pi-ai";
+export type { ApiKeyCredential, AuthCredential, AuthCredentialEntry, AuthCredentialStore, AuthStorageData, AuthStorageOptions, CredentialOrigin, CredentialOriginKind, OAuthAccountIdentity, OAuthCredential, ResetCreditAccountStatus, ResetCreditRedeemOutcome, ResetCreditTarget, SerializedAuthStorage, StoredAuthCredential, } from "@oh-my-pi/pi-ai";
+export { AuthStorage, REMOTE_REFRESH_SENTINEL, SqliteAuthCredentialStore } from "@oh-my-pi/pi-ai";
+export type { SnapshotResponse } from "@oh-my-pi/pi-ai/auth-broker/types";

package/dist/types/session/yield-queue.d.ts

@@ -30,6 +30,8 @@ export declare class YieldQueue {
      * the model between requests without the agent having to stop.
      */
     drainLazy(): Array<() => AgentMessage | null>;
-    clear(): void;
+    /** Drop queued entries. With `kind`, drop only that kind's entries (leaving
+     *  any pending idle-flush for other kinds intact); otherwise drop everything. */
+    clear(kind?: string): void;
 }
 export {};

package/dist/types/tools/browser/attach.d.ts

@@ -1,4 +1,4 @@
-import { type Browser, type Page } from "puppeteer-core";
+import type { Browser, Page } from "puppeteer-core";
 /**
  * Allocate an unused TCP port on 127.0.0.1 by binding to port 0 and reading
  * back the kernel-assigned port. There's a small race between close and the

package/dist/types/utils/markit.d.ts

@@ -12,13 +12,5 @@ export interface MarkitFileConversionOptions {
      */
     imageDir?: string;
 }
-interface MuPdfWasmModuleConfig {
-    print?: (...values: unknown[]) => void;
-    printErr?: (...values: unknown[]) => void;
-}
-declare global {
-    var $libmupdf_wasm_Module: MuPdfWasmModuleConfig | undefined;
-}
 export declare function convertFileWithMarkit(filePath: string, signal?: AbortSignal, options?: MarkitFileConversionOptions): Promise<MarkitConversionResult>;
 export declare function convertBufferWithMarkit(buffer: Uint8Array, extension: string, signal?: AbortSignal): Promise<MarkitConversionResult>;
-export {};

package/dist/types/utils/mupdf-wasm-embed.d.ts

@@ -0,0 +1 @@
+export declare function loadEmbeddedMupdfWasm(): Uint8Array | undefined;

package/dist/types/utils/turndown.d.ts

@@ -0,0 +1,15 @@
+import TurndownService from "turndown";
+/**
+ * Build a Turndown instance configured for GFM with the fixes omp relies on:
+ * `~~strikethrough~~`, unescaped heading periods, and single-space list markers.
+ *
+ * Shared by the web scrapers (HTML → markdown) and the markit document engine
+ * (`src/markit`). The rule set must stay identical across both call sites.
+ */
+export declare function createTurndown(): TurndownService;
+/**
+ * Normalize HTML tables so turndown-plugin-gfm can render them:
+ * - strip `<p>` tags inside `<td>`/`<th>` cells (joining paragraphs with a space)
+ * - wrap the first row in `<thead>` when missing
+ */
+export declare function normalizeTablesHtml(html: string): string;