jeopi-cli 16.2.14 → 16.2.17

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/mcp/client.d.ts

@@ -0,0 +1,83 @@
+import type { MCPGetPromptResult, MCPPrompt, MCPRequestOptions, MCPResource, MCPResourceReadResult, MCPResourceTemplate, MCPServerCapabilities, MCPServerConfig, MCPServerConnection, MCPToolCallResult, MCPToolDefinition } from "./types";
+/**
+ * Connect to an MCP server.
+ * Has a 30 second timeout by default to prevent blocking startup.
+ * Set JEOPI_MCP_TIMEOUT_MS=0 to disable MCP client-side timeouts.
+ */
+export declare function connectToServer(name: string, config: MCPServerConfig, options?: {
+    signal?: AbortSignal;
+    onNotification?: (method: string, params: unknown) => void;
+    onRequest?: (method: string, params: unknown) => Promise<unknown>;
+}): Promise<MCPServerConnection>;
+/**
+ * List tools from a connected server.
+ */
+export declare function listTools(connection: MCPServerConnection, options?: {
+    signal?: AbortSignal;
+}): Promise<MCPToolDefinition[]>;
+/**
+ * Call a tool on a connected server.
+ */
+export declare function callTool(connection: MCPServerConnection, toolName: string, args?: Record<string, unknown>, options?: MCPRequestOptions): Promise<MCPToolCallResult>;
+/**
+ * Disconnect from a server.
+ */
+export declare function disconnectServer(connection: MCPServerConnection): Promise<void>;
+/**
+ * Check if a server supports tools.
+ */
+export declare function serverSupportsTools(capabilities: MCPServerCapabilities): boolean;
+/**
+ * List resources from a connected server.
+ */
+export declare function listResources(connection: MCPServerConnection, options?: {
+    signal?: AbortSignal;
+}): Promise<MCPResource[]>;
+/**
+ * List resource templates from a connected server.
+ *
+ * A server MAY advertise the `resources` capability without implementing the
+ * optional `resources/templates/list` method (it is optional in the MCP spec).
+ * Such servers reject the request with JSON-RPC -32601 ("Method not found").
+ * Treat that as "no templates" and return `[]` rather than throwing — otherwise
+ * a caller that loads resources and templates together (see `MCPManager`'s
+ * `Promise.all([listResources, listResourceTemplates])`) would discard the
+ * server's concrete resources too. Any other error still propagates.
+ */
+export declare function listResourceTemplates(connection: MCPServerConnection, options?: {
+    signal?: AbortSignal;
+}): Promise<MCPResourceTemplate[]>;
+/**
+ * Read a resource from a connected server.
+ */
+export declare function readResource(connection: MCPServerConnection, uri: string, options?: MCPRequestOptions): Promise<MCPResourceReadResult>;
+/**
+ * Subscribe to resource update notifications.
+ */
+export declare function subscribeToResources(connection: MCPServerConnection, uris: string[], options?: MCPRequestOptions): Promise<void>;
+/**
+ * Unsubscribe from resource update notifications.
+ */
+export declare function unsubscribeFromResources(connection: MCPServerConnection, uris: string[], options?: MCPRequestOptions): Promise<void>;
+/**
+ * Check if a server supports resource subscriptions.
+ */
+export declare function serverSupportsResourceSubscriptions(capabilities: MCPServerCapabilities): boolean;
+/**
+ * Check if a server supports resources.
+ */
+export declare function serverSupportsResources(capabilities: MCPServerCapabilities): boolean;
+/**
+ * List prompts from a connected server.
+ */
+export declare function listPrompts(connection: MCPServerConnection, options?: {
+    signal?: AbortSignal;
+}): Promise<MCPPrompt[]>;
+/**
+ * Get a specific prompt from a connected server.
+ */
+export declare function getPrompt(connection: MCPServerConnection, name: string, args?: Record<string, string>, options?: MCPRequestOptions): Promise<MCPGetPromptResult>;
+/**
+ * Check if a server supports prompts.
+ */
+export declare function serverSupportsPrompts(capabilities: MCPServerCapabilities): boolean;

package/dist/types/mcp/config-writer.d.ts

@@ -0,0 +1,101 @@
+import { type MCPConfigFile, type MCPServerConfig } from "./types";
+/**
+ * Read an MCP config file.
+ * Returns empty config if file doesn't exist.
+ */
+export declare function readMCPConfigFile(filePath: string): Promise<MCPConfigFile>;
+/**
+ * Write an MCP config file atomically.
+ * Creates parent directories if they don't exist.
+ */
+export declare function writeMCPConfigFile(filePath: string, config: MCPConfigFile): Promise<void>;
+/**
+ * Validate server name.
+ * @returns Error message if invalid, undefined if valid
+ */
+export declare function validateServerName(name: string): string | undefined;
+/**
+ * Add an MCP server to a config file.
+ * Validates the config before writing.
+ *
+ * @throws Error if server name already exists or validation fails
+ */
+export declare function addMCPServer(filePath: string, name: string, config: MCPServerConfig): Promise<void>;
+/**
+ * Update an existing MCP server in a config file.
+ * If the server doesn't exist, this will add it.
+ *
+ * @throws Error if validation fails
+ */
+export declare function updateMCPServer(filePath: string, name: string, config: MCPServerConfig): Promise<void>;
+/**
+ * Remove an MCP server from a config file.
+ *
+ * @throws Error if server doesn't exist
+ */
+export declare function removeMCPServer(filePath: string, name: string): Promise<void>;
+/**
+ * Get a specific server config from a file.
+ * Returns undefined if server doesn't exist.
+ */
+export declare function getMCPServer(filePath: string, name: string): Promise<MCPServerConfig | undefined>;
+/**
+ * List all server names in a config file.
+ */
+export declare function listMCPServers(filePath: string): Promise<string[]>;
+/**
+ * Read the disabled servers list from a config file.
+ */
+export declare function readDisabledServers(filePath: string): Promise<string[]>;
+/**
+ * Add or remove a server name from the disabled servers list.
+ */
+export declare function setServerDisabled(filePath: string, name: string, disabled: boolean): Promise<void>;
+/**
+ * Read the user-level force-enable list (allowlist that overrides a
+ * non-writable source config's `enabled: false`).
+ */
+export declare function readEnabledServers(filePath: string): Promise<string[]>;
+/**
+ * Add or remove a server name from the user-level force-enable list.
+ * The list overrides a discovered server's `enabled: false` flag but does
+ * NOT override the `disabledServers` denylist.
+ */
+export declare function setServerForceEnabled(filePath: string, name: string, force: boolean): Promise<void>;
+/** Paths and target state for toggling one MCP server across known config files. */
+export interface SetMcpServerEnabledOptions {
+    userPath: string;
+    projectPath: string;
+    /**
+     * Absolute path to the loaded row's source mcp.json. Provide ONLY for
+     * formats this codebase owns (native `.jeopi/mcp.json` and `mcp-json`
+     * `mcp.json`/`.mcp.json`). Tool-owned configs (opencode.json, claude.json,
+     * settings.json …) MUST be omitted; we never mutate another tool's file.
+     */
+    sourcePath?: string;
+    name: string;
+    enabled: boolean;
+}
+/**
+ * Flip a server's enabled/disabled state regardless of where it lives.
+ *
+ * Resolution order, mirroring `/mcp enable` / `/mcp disable` plus the dashboard
+ * fix for non-writable source configs:
+ *
+ * - Server found in `sourcePath` (writable) → write `enabled` on that entry.
+ * - Else server in project mcp.json → write `enabled` there.
+ * - Else server in user mcp.json → write `enabled` there.
+ * - Else (server defined in a tool-owned source like opencode.json, OR a
+ *   purely discovered server):
+ *   - Disable → add to the user-level `disabledServers` denylist.
+ *   - Enable → add to the user-level `enabledServers` allowlist so the
+ *     dashboard / runtime override the non-writable source's
+ *     `enabled: false` flag.
+ *
+ * Cleanup invariants — on every call:
+ * - Re-enable clears any stale denylist entry so a server disabled via
+ *   `/mcp disable` and re-enabled here doesn't stay suppressed.
+ * - Disable clears any stale allowlist entry so re-disabling a
+ *   force-enabled server actually takes effect.
+ */
+export declare function setMcpServerEnabled(options: SetMcpServerEnabledOptions): Promise<void>;

package/dist/types/mcp/config.d.ts

@@ -0,0 +1,75 @@
+/**
+ * MCP configuration loader.
+ *
+ * Uses the capability system to load MCP servers from multiple sources.
+ */
+import type { SourceMeta } from "../capability/types";
+import type { MCPServerConfig } from "./types";
+/** Options for loading MCP configs */
+export interface LoadMCPConfigsOptions {
+    /** Whether to load project-level config (default: true) */
+    enableProjectConfig?: boolean;
+    /** Whether to filter out Exa MCP servers (default: true) */
+    filterExa?: boolean;
+    /** Whether to filter out browser MCP servers when builtin browser tool is enabled (default: false) */
+    filterBrowser?: boolean;
+}
+/** Result of loading MCP configs */
+export interface LoadMCPConfigsResult {
+    /** Loaded server configs */
+    configs: Record<string, MCPServerConfig>;
+    /** Extracted Exa API keys (if any were filtered) */
+    exaApiKeys: string[];
+    /** Source metadata for each server */
+    sources: Record<string, SourceMeta>;
+}
+/**
+ * Load all MCP server configs from standard locations.
+ * Uses the capability system for multi-source discovery.
+ *
+ * @param cwd Working directory (project root)
+ * @param options Load options
+ */
+export declare function loadAllMCPConfigs(cwd: string, options?: LoadMCPConfigsOptions): Promise<LoadMCPConfigsResult>;
+/**
+ * Check if a server config is an Exa MCP server.
+ */
+export declare function isExaMCPServer(name: string, config: MCPServerConfig): boolean;
+/**
+ * Extract Exa API key from an MCP server config.
+ */
+export declare function extractExaApiKey(config: MCPServerConfig): string | undefined;
+/** Result of filtering Exa MCP servers */
+export interface ExaFilterResult {
+    /** Configs with Exa servers removed */
+    configs: Record<string, MCPServerConfig>;
+    /** Extracted Exa API keys (if any) */
+    exaApiKeys: string[];
+    /** Source metadata for remaining servers */
+    sources: Record<string, SourceMeta>;
+}
+/**
+ * Filter out Exa MCP servers and extract their API keys.
+ * Since we have native Exa integration, we don't need the MCP server.
+ */
+export declare function filterExaMCPServers(configs: Record<string, MCPServerConfig>, sources: Record<string, SourceMeta>): ExaFilterResult;
+/**
+ * Validate server config has required fields.
+ */
+export declare function validateServerConfig(name: string, config: MCPServerConfig): string[];
+/**
+ * Check if a server config is a browser automation MCP server.
+ */
+export declare function isBrowserMCPServer(name: string, config: MCPServerConfig): boolean;
+/** Result of filtering browser MCP servers */
+export interface BrowserFilterResult {
+    /** Configs with browser servers removed */
+    configs: Record<string, MCPServerConfig>;
+    /** Source metadata for remaining servers */
+    sources: Record<string, SourceMeta>;
+}
+/**
+ * Filter out browser automation MCP servers.
+ * Since we have a native browser tool, we don't need these MCP servers.
+ */
+export declare function filterBrowserMCPServers(configs: Record<string, MCPServerConfig>, sources: Record<string, SourceMeta>): BrowserFilterResult;

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

@@ -0,0 +1,18 @@
+/**
+ * MCP (Model Context Protocol) support.
+ *
+ * Provides per-project .mcp.json configuration for connecting to
+ * MCP servers via stdio or HTTP transports.
+ */
+export * from "./client";
+export * from "./config";
+export * from "./config-writer";
+export { callMCP, parseSSE } from "./json-rpc";
+export * from "./loader";
+export * from "./manager";
+export * from "./oauth-discovery";
+export * from "./tool-bridge";
+export * from "./tool-cache";
+export * from "./transports/http";
+export * from "./transports/stdio";
+export * from "./types";

package/dist/types/mcp/json-rpc.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Redact credential-bearing query params (e.g. `exaApiKey`) so failed
+ * requests never write secrets to the persistent log file.
+ */
+export declare function redactUrlForLog(url: string): string;
+/** Parse SSE response format (lines starting with "data: ") */
+export declare function parseSSE(text: string): unknown;
+/** JSON-RPC 2.0 response structure */
+export interface JsonRpcResponse<T = unknown> {
+    jsonrpc: "2.0";
+    id: string | number;
+    result?: T;
+    error?: {
+        code: number;
+        message: string;
+        data?: unknown;
+    };
+}
+/** Options controlling a single MCP JSON-RPC HTTP request. */
+export interface CallMcpOptions {
+    signal?: AbortSignal;
+}
+/**
+ * Call an MCP server with JSON-RPC 2.0 over HTTPS.
+ *
+ * @param url - Full MCP server URL (including any query parameters)
+ * @param method - JSON-RPC method name (e.g., "tools/list", "tools/call")
+ * @param params - Method parameters
+ * @param options - Optional transport controls such as cancellation.
+ * @returns Parsed JSON-RPC response
+ */
+export declare function callMCP<T = unknown>(url: string, method: string, params?: Record<string, unknown>, options?: CallMcpOptions): Promise<JsonRpcResponse<T>>;

package/dist/types/mcp/loader.d.ts

@@ -0,0 +1,44 @@
+import type { LoadedCustomTool } from "../extensibility/custom-tools/types";
+import { AgentStorage } from "../session/agent-storage";
+import type { AuthStorage } from "../session/auth-storage";
+import { MCPManager } from "./manager";
+import type { McpConnectionStatusEvent } from "./startup-events";
+/** Result from loading MCP tools */
+export interface MCPToolsLoadResult {
+    /** MCP manager (for lifecycle management) */
+    manager: MCPManager;
+    /** Loaded tools as LoadedCustomTool format */
+    tools: LoadedCustomTool[];
+    /** Errors keyed by server name */
+    errors: Array<{
+        path: string;
+        error: string;
+    }>;
+    /** Connected server names */
+    connectedServers: string[];
+    /** Extracted Exa API keys from filtered MCP servers */
+    exaApiKeys: string[];
+}
+/** Options for loading MCP tools */
+export interface MCPToolsLoadOptions {
+    /** Called when MCP server connection state changes. */
+    onStatus?: (event: McpConnectionStatusEvent) => void;
+    /** Whether to load project-level config (default: true) */
+    enableProjectConfig?: boolean;
+    /** Whether to filter out Exa MCP servers (default: true) */
+    filterExa?: boolean;
+    /** Whether to filter out browser MCP servers when builtin browser tool is enabled (default: false) */
+    filterBrowser?: boolean;
+    /** SQLite storage for MCP tool cache (null disables cache) */
+    cacheStorage?: AgentStorage | null;
+    /** Auth storage used to resolve OAuth credentials before initial MCP connect */
+    authStorage?: AuthStorage;
+}
+/**
+ * Discover and load MCP tools from .mcp.json files.
+ *
+ * @param cwd Working directory (project root)
+ * @param options Load options including progress callbacks
+ * @returns MCP tools in LoadedCustomTool format for integration
+ */
+export declare function discoverAndLoadMCPTools(cwd: string, options?: MCPToolsLoadOptions): Promise<MCPToolsLoadResult>;