@oh-my-pi/pi-coding-agent 15.1.1 → 15.1.3

package/dist/types/debug/report-bundle.d.ts

@@ -0,0 +1,55 @@
+import type { WorkProfile } from "@oh-my-pi/pi-natives";
+import type { CpuProfile, HeapSnapshot } from "./profiler";
+export interface ReportBundleOptions {
+    /** Session file path */
+    sessionFile: string | undefined;
+    /** Settings to include */
+    settings?: Record<string, unknown>;
+    /** CPU profile (for performance reports) */
+    cpuProfile?: CpuProfile;
+    /** Heap snapshot (for memory reports) */
+    heapSnapshot?: HeapSnapshot;
+    /** Work profile (for work scheduling reports) */
+    workProfile?: WorkProfile;
+}
+export interface ReportBundleResult {
+    path: string;
+    files: string[];
+}
+export interface DebugLogSource {
+    getInitialText(): Promise<string>;
+    hasOlderLogs(): boolean;
+    loadOlderLogs(limitDays?: number): Promise<string>;
+}
+/**
+ * Create a debug report bundle.
+ *
+ * Bundle contents:
+ * - session.jsonl: Current session transcript
+ * - artifacts/: Session artifacts directory
+ * - subagents/: Subagent sessions + artifacts
+ * - logs.txt: Recent log entries
+ * - system.json: OS, arch, CPU, memory, versions
+ * - env.json: Sanitized environment variables
+ * - config.json: Resolved settings
+ * - profile.cpuprofile: CPU profile (performance report only)
+ * - profile.md: Markdown CPU profile (performance report only)
+ * - heap.heapsnapshot: Heap snapshot (memory report only)
+ * - work.folded: Work profile folded stacks (work report only)
+ * - work.md: Work profile summary (work report only)
+ * - work.svg: Work profile flamegraph (work report only)
+ */
+export declare function createReportBundle(options: ReportBundleOptions): Promise<ReportBundleResult>;
+/** Get recent log entries for display (tail-limited to avoid OOM on large files). */
+export declare function getLogText(): Promise<string>;
+export declare function createDebugLogSource(): Promise<DebugLogSource>;
+/** Calculate total size of artifact cache */
+export declare function getArtifactCacheStats(sessionsDir: string): Promise<{
+    count: number;
+    totalSize: number;
+    oldestDate: Date | null;
+}>;
+/** Clear artifact cache older than N days */
+export declare function clearArtifactCache(sessionsDir: string, daysOld?: number): Promise<{
+    removed: number;
+}>;

package/dist/types/debug/system-info.d.ts

@@ -0,0 +1,26 @@
+/**
+ * System information collection for debug reports.
+ */
+export interface SystemInfo {
+    os: string;
+    arch: string;
+    cpu: string;
+    memory: {
+        total: number;
+        free: number;
+    };
+    versions: {
+        app: string;
+        bun: string;
+        node: string;
+    };
+    cwd: string;
+    shell: string;
+    terminal: string | undefined;
+}
+/** Collect system information */
+export declare function collectSystemInfo(): Promise<SystemInfo>;
+/** Format system info for display */
+export declare function formatSystemInfo(info: SystemInfo): string;
+/** Sanitize environment variables by redacting sensitive values */
+export declare function sanitizeEnv(env: Record<string, string | undefined>): Record<string, string>;

package/dist/types/discovery/agents-md.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/discovery/agents.d.ts

@@ -0,0 +1,12 @@
+import type { LoadContext } from "../capability/types";
+/**
+ * Project-level paths: walk up from cwd to repoRoot, returning `.agent/<segments>`
+ * and `.agents/<segments>` at each ancestor.
+ *
+ * The user home directory is skipped: `~/.agent[s]/` is by definition
+ * user-level config and is already enumerated by {@link getUserPathCandidates}.
+ * Without this guard, any cwd under `$HOME` (with no closer git repoRoot) would
+ * walk up to home and yield duplicate project+user entries for the same
+ * directory — see https://github.com/can1357/oh-my-pi/issues/1116.
+ */
+export declare function getProjectPathCandidates(ctx: LoadContext, ...segments: string[]): string[];

package/dist/types/discovery/builtin.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/discovery/claude-plugins.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/discovery/claude.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/discovery/cline.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/discovery/codex.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/discovery/cursor.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Cursor Provider
+ *
+ * Loads configuration from Cursor's config directories.
+ * Priority: 50 (tool-specific provider)
+ *
+ * Sources:
+ * - User: ~/.cursor
+ * - Project: .cursor/ (cwd only)
+ *
+ * Capabilities:
+ * - mcps: From mcp.json with mcpServers key
+ * - rules: From rules/*.mdc files with MDC frontmatter (description, globs, alwaysApply)
+ * - settings: From settings.json if present
+ */
+export {};

package/dist/types/discovery/gemini.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/discovery/github.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/discovery/helpers.d.ts

@@ -0,0 +1,267 @@
+import type { ThinkingLevel } from "@oh-my-pi/pi-agent-core";
+import type { ExtensionModule } from "../capability/extension-module";
+import { type Rule } from "../capability/rule";
+import type { Skill } from "../capability/skill";
+import type { LoadContext, LoadResult, SourceMeta } from "../capability/types";
+/**
+ * Standard paths for each config source.
+ */
+export declare const SOURCE_PATHS: {
+    readonly native: {
+        readonly userBase: string;
+        readonly userAgent: string;
+        projectDir: string;
+    };
+    readonly claude: {
+        readonly userBase: ".claude";
+        readonly userAgent: ".claude";
+        readonly projectDir: ".claude";
+    };
+    readonly codex: {
+        readonly userBase: ".codex";
+        readonly userAgent: ".codex";
+        readonly projectDir: ".codex";
+    };
+    readonly gemini: {
+        readonly userBase: ".gemini";
+        readonly userAgent: ".gemini";
+        readonly projectDir: ".gemini";
+    };
+    readonly opencode: {
+        readonly userBase: ".config/opencode";
+        readonly userAgent: ".config/opencode";
+        readonly projectDir: ".opencode";
+    };
+    readonly cursor: {
+        readonly userBase: ".cursor";
+        readonly userAgent: ".cursor";
+        readonly projectDir: ".cursor";
+    };
+    readonly windsurf: {
+        readonly userBase: ".codeium/windsurf";
+        readonly userAgent: ".codeium/windsurf";
+        readonly projectDir: ".windsurf";
+    };
+    readonly cline: {
+        readonly userBase: ".cline";
+        readonly userAgent: ".cline";
+        readonly projectDir: null;
+    };
+    readonly github: {
+        readonly userBase: null;
+        readonly userAgent: null;
+        readonly projectDir: ".github";
+    };
+    readonly vscode: {
+        readonly userBase: ".vscode";
+        readonly userAgent: ".vscode";
+        readonly projectDir: ".vscode";
+    };
+};
+export type SourceId = keyof typeof SOURCE_PATHS;
+/**
+ * Get user-level path for a source.
+ */
+export declare function getUserPath(ctx: LoadContext, source: SourceId, subpath: string): string | null;
+/**
+ * Get project-level path for a source (cwd only).
+ */
+export declare function getProjectPath(ctx: LoadContext, source: SourceId, subpath: string): string | null;
+/**
+ * Create source metadata for an item.
+ */
+export declare function createSourceMeta(provider: string, filePath: string, level: "user" | "project"): SourceMeta;
+export declare function parseBoolean(value: unknown): boolean | undefined;
+/**
+ * Parse a comma-separated string into an array of trimmed, non-empty strings.
+ */
+export declare function parseCSV(value: string): string[];
+/**
+ * Parse a value that may be an array of strings or a comma-separated string.
+ * Returns undefined if the result would be empty.
+ */
+export declare function parseArrayOrCSV(value: unknown): string[] | undefined;
+/**
+ * Build a canonical rule item from a markdown/markdown-frontmatter document.
+ */
+export declare function buildRuleFromMarkdown(name: string, content: string, filePath: string, source: SourceMeta, options?: {
+    ruleName?: string;
+    stripNamePattern?: RegExp;
+}): Rule;
+/**
+ * Parse model field into a prioritized list.
+ */
+export declare function parseModelList(value: unknown): string[] | undefined;
+/** Parsed agent fields from frontmatter (excludes source/filePath/systemPrompt) */
+export interface ParsedAgentFields {
+    name: string;
+    description: string;
+    tools?: string[];
+    spawns?: string[] | "*";
+    model?: string[];
+    output?: unknown;
+    thinkingLevel?: ThinkingLevel;
+    blocking?: boolean;
+}
+/**
+ * Parse agent fields from frontmatter.
+ * Returns null if required fields (name, description) are missing.
+ */
+export declare function parseAgentFields(frontmatter: Record<string, unknown>): ParsedAgentFields | null;
+export interface ScanSkillsFromDirOptions {
+    dir: string;
+    providerId: string;
+    level: "user" | "project";
+    requireDescription?: boolean;
+}
+export declare function compareSkillOrder(aName: string, aPath: string, bName: string, bPath: string): number;
+export declare function scanSkillsFromDir(_ctx: LoadContext, options: ScanSkillsFromDirOptions): Promise<LoadResult<Skill>>;
+/**
+ * Recursively expand environment variables in an object.
+ */
+export declare function expandEnvVarsDeep<T>(obj: T, extraEnv?: Record<string, string>): T;
+/**
+ * Load files from a directory matching extensions.
+ * Uses native glob for fast filesystem scanning with gitignore support.
+ */
+export declare function loadFilesFromDir<T>(_ctx: LoadContext, dir: string, provider: string, level: "user" | "project", options: {
+    /** File extensions to match (without dot) */
+    extensions?: string[];
+    /** Transform file to item (return null to skip) */
+    transform: (name: string, content: string, path: string, source: SourceMeta) => T | null;
+    /** Whether to recurse into subdirectories (default: false) */
+    recursive?: boolean;
+}): Promise<LoadResult<T>>;
+/**
+ * Calculate depth of target directory relative to current working directory.
+ * Depth is the number of directory levels from cwd to target.
+ * - Positive depth: target is above cwd (parent/ancestor)
+ * - Zero depth: target is cwd
+ * - This uses path splitting to count directory levels
+ */
+export declare function calculateDepth(cwd: string, targetDir: string, separator: string): number;
+/**
+ * Discover extension module entry points in a directory.
+ *
+ * Discovery rules:
+ * 1. Direct files: `extensions/*.ts` or `*.js` → load
+ * 2. Subdirectory with index: `extensions/<ext>/index.ts` or `index.js` → load
+ * 3. Subdirectory with package.json: `extensions/<ext>/package.json` with "omp"/"pi" field → load declared paths
+ *
+ * No recursion beyond one level. Complex packages must use package.json manifest.
+ * Uses native glob for fast filesystem scanning with gitignore support.
+ */
+export declare function discoverExtensionModulePaths(_ctx: LoadContext, dir: string): Promise<string[]>;
+/**
+ * Derive a stable extension name from a path.
+ */
+export declare function getExtensionNameFromPath(extensionPath: string): string;
+/**
+ * Build ExtensionModule items from discovered user/project paths.
+ * Shared across providers that expose extension modules via user + project dirs.
+ */
+export declare function buildExtensionModuleItems(providerId: string, userPaths: string[], projectPaths: string[]): ExtensionModule[];
+/**
+ * Entry for an installed Claude Code plugin.
+ */
+export interface ClaudePluginEntry {
+    scope: "user" | "project";
+    installPath: string;
+    version: string;
+    installedAt: string;
+    lastUpdated: string;
+    gitCommitSha?: string;
+    enabled?: boolean;
+}
+/**
+ * Claude Code installed_plugins.json registry format.
+ */
+export interface ClaudePluginsRegistry {
+    version: number;
+    plugins: Record<string, ClaudePluginEntry[]>;
+}
+/**
+ * Resolved plugin root for loading.
+ */
+export interface ClaudePluginRoot {
+    /** Plugin ID (e.g., "simpleclaude-core@simpleclaude") */
+    id: string;
+    /** Marketplace name */
+    marketplace: string;
+    /** Plugin name */
+    plugin: string;
+    /** Version string */
+    version: string;
+    /** Absolute path to plugin root */
+    path: string;
+    /** Whether this is a user or project scope plugin */
+    scope: "user" | "project";
+}
+/**
+ * Parse Claude Code installed_plugins.json content.
+ */
+export declare function parseClaudePluginsRegistry(content: string): ClaudePluginsRegistry | null;
+/**
+ * Resolve the active project registry path by walking up from `cwd`.
+ *
+ * Walk order:
+ * 1. Walk up from `cwd` looking for the nearest directory containing `.omp/`.
+ *    The first match returns `<dir>/.omp/plugins/installed_plugins.json`.
+ * 2. If no `.omp/` is found, rescan from `cwd` upward looking for `.git`.
+ *    The git root is used as an anchor: `<gitRoot>/.omp/plugins/installed_plugins.json`.
+ * 3. If neither is found, return `null` — no project context is active.
+ *
+ * This is the single source of truth for "active project root" used by install,
+ * uninstall, list, upgrade, discovery, and doctor. Deterministic for a given `cwd`.
+ */
+export declare function resolveActiveProjectRegistryPath(cwd: string): Promise<string | null>;
+/**
+ * Like resolveActiveProjectRegistryPath, but falls back to `<cwd>/.omp/plugins/installed_plugins.json`
+ * when no project anchor (.omp/ or .git/) is found.
+ *
+ * Use this when the caller accepts an explicit --scope project so that installing into a freshly
+ * bootstrapped directory (no .omp/ or .git/ yet) works: writeInstalledPluginsRegistry auto-creates
+ * the directory tree on first write.
+ *
+ * Returns undefined when cwd is os.homedir() — that path is already the user registry and must
+ * never alias as the project registry.
+ */
+export declare function resolveOrDefaultProjectRegistryPath(cwd: string): Promise<string | undefined>;
+/**
+ * List all installed Claude Code plugin roots from the plugin cache.
+ * Reads ~/.claude/plugins/installed_plugins.json and ~/.omp/plugins/installed_plugins.json,
+ * and optionally the nearest project-scoped registry resolved from `cwd`.
+ *
+ * Results are cached per `home:resolvedProjectPath` key to avoid repeated parsing.
+ */
+export declare function listClaudePluginRoots(home: string, cwd?: string): Promise<{
+    roots: ClaudePluginRoot[];
+    warnings: string[];
+}>;
+/**
+ * Clear the plugin roots cache (useful for testing or when plugins change).
+ */
+export declare function clearClaudePluginRootsCache(): void;
+/**
+ * Invalidate fs caches for installed-plugin registry files and reset the
+ * in-memory plugin roots cache. Used by MarketplaceManager clients after
+ * installing/uninstalling/enabling/disabling plugins.
+ */
+export declare function clearPluginRootsAndCaches(extraPaths?: readonly string[]): void;
+/**
+ * Populate the module-level plugin roots cache for sync consumers.
+ * Call during session initialization, after dir resolution completes
+ * but before any LSP config is read.
+ */
+export declare function preloadPluginRoots(home: string, cwd?: string): Promise<void>;
+/**
+ * Get pre-loaded plugin roots synchronously.
+ * Returns empty array if preloadPluginRoots() hasn't been called.
+ */
+export declare function getPreloadedPluginRoots(): readonly ClaudePluginRoot[];
+/**
+ * Inject synthetic plugin roots from --plugin-dir paths.
+ * These are prepended to the cache with highest precedence (before OMP/Claude entries).
+ * Must be called before any listClaudePluginRoots() access.
+ */
+export declare function injectPluginDirRoots(home: string, dirs: string[], cwd?: string): Promise<void>;

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

@@ -0,0 +1,51 @@
+/**
+ * Discovery Module
+ *
+ * Auto-registers all providers by importing them.
+ * Import this module to ensure all providers are registered with the capability registry.
+ */
+import "../capability/context-file";
+import "../capability/extension";
+import "../capability/extension-module";
+import "../capability/hook";
+import "../capability/instruction";
+import "../capability/mcp";
+import "../capability/prompt";
+import "../capability/rule";
+import "../capability/settings";
+import "../capability/skill";
+import "../capability/slash-command";
+import "../capability/ssh";
+import "../capability/system-prompt";
+import "../capability/tool";
+import "./agents-md";
+import "./builtin";
+import "./claude";
+import "./claude-plugins";
+import "./cline";
+import "./agents";
+import "./codex";
+import "./cursor";
+import "./gemini";
+import "./opencode";
+import "./github";
+import "./mcp-json";
+import "./ssh";
+import "./vscode";
+import "./windsurf";
+export { cacheStats, disableProvider, enableProvider, getAllCapabilitiesInfo, getAllProvidersInfo, getCapability, getCapabilityInfo, getDisabledProviders, getProviderInfo, initializeWithSettings, invalidate, isProviderEnabled, listCapabilities, loadCapability, reset, setDisabledProviders, } from "../capability";
+export type { ContextFile } from "../capability/context-file";
+export type { Extension, ExtensionManifest } from "../capability/extension";
+export type { ExtensionModule } from "../capability/extension-module";
+export type { Hook } from "../capability/hook";
+export type { Instruction } from "../capability/instruction";
+export type { MCPServer } from "../capability/mcp";
+export type { Prompt } from "../capability/prompt";
+export type { Rule, RuleFrontmatter } from "../capability/rule";
+export type { Settings } from "../capability/settings";
+export type { Skill, SkillFrontmatter } from "../capability/skill";
+export type { SlashCommand } from "../capability/slash-command";
+export type { SSHHost } from "../capability/ssh";
+export type { SystemPrompt } from "../capability/system-prompt";
+export type { CustomTool } from "../capability/tool";
+export type * from "../capability/types";

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

@@ -0,0 +1 @@
+export {};

package/dist/types/discovery/opencode.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/discovery/plugin-dir-roots.d.ts

@@ -0,0 +1,15 @@
+/** Synthetic plugin root for a --plugin-dir path. Shape-compatible with ClaudePluginRoot. */
+export interface PluginDirRoot {
+    id: string;
+    marketplace: string;
+    plugin: string;
+    version: string;
+    path: string;
+    scope: "user" | "project";
+}
+/**
+ * Build a synthetic plugin root from a --plugin-dir resolved path.
+ * @param resolvedPath Absolute path to the plugin directory
+ * @param manifestName Plugin name from manifest; falls back to directory basename
+ */
+export declare function buildPluginDirRoot(resolvedPath: string, manifestName?: string): PluginDirRoot;

package/dist/types/discovery/ssh.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/discovery/substitute-plugin-root.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Recursively substitute ${CLAUDE_PLUGIN_ROOT} and ${OMP_PLUGIN_ROOT}
+ * with the actual plugin root path in strings, arrays, and plain objects.
+ */
+export declare function substitutePluginRoot<T>(value: T, rootPath: string): T;

package/dist/types/discovery/vscode.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/discovery/windsurf.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Windsurf (Codeium) Provider
+ *
+ * Loads configuration from Windsurf's config locations:
+ * - User: ~/.codeium/windsurf
+ * - Project: .windsurf
+ *
+ * Supports:
+ * - MCP servers from mcp_config.json
+ * - Rules from .windsurf/rules/*.md and ~/.codeium/windsurf/memories/global_rules.md
+ * - Legacy .windsurfrules file
+ */
+export {};

package/dist/types/edit/apply-patch/index.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Multi-file orchestrator for the Codex `apply_patch` envelope.
+ *
+ * Decoupled from tool-registration: takes raw patch text + options, parses
+ * it, and applies each hunk via the existing single-file `applyPatch` in
+ * `../modes/patch.ts`. A future OpenAI freeform/grammar tool variant can
+ * call this directly with the raw grammar output.
+ *
+ * Per spec §6.1, hunks are applied in order and NOT atomically — if hunk
+ * N fails, hunks `0..N-1` are already on disk. We surface that by
+ * returning the per-file results alongside the error when it happens.
+ */
+import { type ApplyPatchOptions, type ApplyPatchResult } from "../modes/patch";
+export * from "./parser";
+export interface ApplyCodexPatchResult {
+    /** Single-file apply results in the order they were attempted. */
+    results: ApplyPatchResult[];
+    /** Affected file paths grouped by operation, for the §9.1 summary. */
+    affected: {
+        added: string[];
+        modified: string[];
+        deleted: string[];
+    };
+}
+/**
+ * Apply a full Codex `*** Begin Patch` envelope.
+ *
+ * Note: renames are reported under `modified` with the original path (spec
+ * §9.1), not as a delete + add.
+ */
+export declare function applyCodexPatch(patchText: string, options: ApplyPatchOptions): Promise<ApplyCodexPatchResult>;
+/**
+ * Format the A/M/D summary described in spec §9.1.
+ */
+export declare function formatApplyCodexPatchSummary(affected: ApplyCodexPatchResult["affected"]): string;

package/dist/types/edit/apply-patch/parser.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Parser for the Codex `apply_patch` envelope format.
+ *
+ *     *** Begin Patch
+ *     *** Add File: <path>
+ *     +<line>
+ *     *** Delete File: <path>
+ *     *** Update File: <path>
+ *     *** Move to: <newpath>
+ *     @@ <optional context>
+ *     -old
+ *     +new
+ *      context
+ *     *** End of File
+ *     *** End Patch
+ *
+ * Input is the full envelope text (optionally heredoc-wrapped). Output is a
+ * list of `PatchInput` records, each ready to hand to the existing
+ * single-file `applyPatch()` in `../modes/patch.ts`.
+ *
+ * Per spec §4.3 Lenient mode: a `<<EOF` / `<<'EOF'` / `<<"EOF"` heredoc
+ * wrapper around the whole envelope is stripped before parsing.
+ */
+import type { PatchInput } from "../modes/patch";
+/**
+ * Parse a Codex `*** Begin Patch` envelope into a list of single-file
+ * patch inputs.
+ */
+export declare function parseApplyPatch(patchText: string): PatchInput[];
+/**
+ * Best-effort parser for in-progress TUI previews. It tolerates missing
+ * envelope markers and incomplete trailing hunks; do not use it to apply edits.
+ */
+export declare function parseApplyPatchStreaming(patchText: string): PatchInput[];

package/dist/types/edit/diff.d.ts

@@ -0,0 +1,59 @@
+export interface DiffResult {
+    diff: string;
+    firstChangedLine: number | undefined;
+}
+export interface DiffError {
+    error: string;
+}
+export interface DiffHunk {
+    changeContext?: string;
+    oldStartLine?: number;
+    newStartLine?: number;
+    hasContextLines: boolean;
+    oldLines: string[];
+    newLines: string[];
+    isEndOfFile: boolean;
+}
+export declare class ParseError extends Error {
+    readonly lineNumber?: number | undefined;
+    constructor(message: string, lineNumber?: number | undefined);
+}
+export declare class ApplyPatchError extends Error {
+    constructor(message: string);
+}
+/**
+ * Generate a unified diff string with line numbers and context.
+ * Returns both the diff string and the first changed line number (in the new file).
+ */
+export declare function generateDiffString(oldContent: string, newContent: string, contextLines?: number): DiffResult;
+export interface ReplaceOptions {
+    /** Allow fuzzy matching */
+    fuzzy: boolean;
+    /** Replace all occurrences */
+    all: boolean;
+    /** Similarity threshold for fuzzy matching */
+    threshold?: number;
+}
+export interface ReplaceResult {
+    /** The new content after replacements */
+    content: string;
+    /** Number of replacements made */
+    count: number;
+}
+/**
+ * Generate a unified diff string without file headers.
+ * Returns both the diff string and the first changed line number (in the new file).
+ */
+export declare function generateUnifiedDiffString(oldContent: string, newContent: string, contextLines?: number): DiffResult;
+export declare function normalizeDiff(diff: string): string;
+export declare function normalizeCreateContent(content: string): string;
+export declare function parseDiffHunks(diff: string): DiffHunk[];
+/**
+ * Find and replace text in content using fuzzy matching.
+ */
+export declare function replaceText(content: string, oldText: string, newText: string, options: ReplaceOptions): ReplaceResult;
+/**
+ * Compute the diff for an edit operation without applying it.
+ * Used for preview rendering in the TUI before the tool executes.
+ */
+export declare function computeEditDiff(path: string, oldText: string, newText: string, cwd: string, fuzzy?: boolean, all?: boolean, threshold?: number): Promise<DiffResult | DiffError>;

package/dist/types/edit/file-read-cache.d.ts

@@ -0,0 +1,25 @@
+import type { ToolSession } from "../tools";
+export interface FileReadSnapshot {
+    /** 1-indexed line number → exact line content as observed by `read`/`search`. */
+    lines: Map<number, string>;
+    recordedAt: number;
+}
+export declare class FileReadCache {
+    #private;
+    /** Look up the most recent snapshot for `absPath`, or `null` if absent. */
+    get(absPath: string): FileReadSnapshot | null;
+    /** Record a contiguous run of lines (e.g. from a `read` tool). `startLine` is 1-indexed. */
+    recordContiguous(absPath: string, startLine: number, lines: readonly string[]): void;
+    /** Record sparse `(lineNumber, content)` pairs (e.g. `search` matches plus context). */
+    recordSparse(absPath: string, entries: Iterable<readonly [number, string]>): void;
+    /** Drop the snapshot for a single path. */
+    invalidate(absPath: string): void;
+    /** Drop every snapshot. */
+    clear(): void;
+}
+/**
+ * Look up (or lazily create) the file-read cache attached to a session. The
+ * cache is stored as `session.fileReadCache` so it lives exactly as long as
+ * the session itself.
+ */
+export declare function getFileReadCache(session: ToolSession): FileReadCache;