jeopi-cli 16.2.14 → 16.2.17

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

@@ -0,0 +1,36 @@
+import type { Theme, ThemeBg } from "../modes/theme/theme";
+import type { State } from "./types";
+export { Ellipsis, truncateToWidth } from "jeopi-tui";
+/**
+ * Incremental xxHash64 key builder.
+ *
+ * Chains `Bun.hash.xxHash64` calls via seeding — each fed value
+ * mixes into the running hash without intermediate string allocations.
+ * Accepts strings, numbers (u32), booleans, bigints, and `undefined`/`null`
+ * (hashed as a sentinel byte) natively.
+ */
+export declare class Hasher {
+    #private;
+    /** Feed a string. */
+    str(s: string): this;
+    /** Feed an unsigned 32-bit integer. */
+    u32(n: number): this;
+    /** Feed a 64-bit bigint. */
+    u64(n: bigint): this;
+    /** Feed a boolean (single byte: 1 = true, 0 = false). */
+    bool(b: boolean): this;
+    /** Feed a value that may be `undefined` or `null` (hashed as a 0xFF sentinel byte). */
+    optional(v: string | undefined | null): this;
+    /** Return the final hash digest. */
+    digest(): bigint;
+}
+/** Render-cache entry used by tool renderers. */
+export interface RenderCache {
+    key: bigint;
+    lines: string[];
+}
+export declare function buildTreePrefix(ancestors: boolean[], theme: Theme): string;
+export declare function getTreeBranch(isLast: boolean, theme: Theme): string;
+export declare function getTreeContinuePrefix(isLast: boolean, theme: Theme): string;
+export declare function padToWidth(text: string, width: number, bgFn?: (s: string) => string): string;
+export declare function getStateBgColor(state: State): ThemeBg;

package/dist/types/tui/width-aware-text.d.ts

@@ -0,0 +1,23 @@
+import { type Component } from "jeopi-tui";
+/**
+ * Text whose content is (re)formatted against the actual render width.
+ *
+ * A plain `Text` receives an already-formatted string and only wraps it at
+ * render time, so width-dependent layout (per-line truncation, inline previews)
+ * has to be decided before the width is known. Renderers used to cope by
+ * hard-capping output lines at a fixed column count (e.g. 80), which truncated
+ * to roughly a third of a wide terminal. This defers formatting to
+ * `render(width)`: it computes the same content width the inner `Text` uses
+ * (mirroring its tight-layout flag so the budget can't desync), hands that to
+ * the formatter, and delegates margins/background/vertical padding to the inner
+ * `Text`. Lines the formatter caps at `contentWidth` fit exactly and so never
+ * wrap.
+ */
+export declare class WidthAwareText implements Component {
+    #private;
+    constructor(format: (contentWidth: number) => string, paddingX?: number, paddingY?: number);
+    setCustomBgFn(customBgFn?: (text: string) => string): void;
+    setIgnoreTight(ignore: boolean): this;
+    invalidate(): void;
+    render(width: number): readonly string[];
+}

package/dist/types/utils/active-repo-context.d.ts

@@ -0,0 +1,8 @@
+export interface ActiveRepoContext {
+    cwd: string;
+    repoRoot: string;
+    relativeRepoRoot: string;
+    source: "single-direct-child-repo";
+}
+export declare function resolveActiveRepoContext(cwd: string): Promise<ActiveRepoContext | null>;
+export declare function resolveActiveRepoContextSync(cwd: string): ActiveRepoContext | null;

package/dist/types/utils/block-context.d.ts

@@ -0,0 +1,35 @@
+export interface LineSpan {
+    startLine: number;
+    endLine: number;
+}
+/** Where the source came from, so tree-sitter can pick a grammar. */
+export interface BlockContextSource {
+    path?: string;
+    lang?: string;
+}
+export type LineEntry = {
+    kind: "line";
+    lineNumber: number;
+    text: string;
+    context: boolean;
+} | {
+    kind: "ellipsis";
+};
+/**
+ * Resolve the off-window boundary lines for a visible window: tree-sitter
+ * syntactic spans first (covers brace and indentation languages), falling back
+ * to a lexical bracket scan when the grammar is unavailable. Returns a map of
+ * `lineNumber → source text` for the lines to surface, never including a line
+ * already visible.
+ */
+export declare function findBlockContextLines(fullLines: readonly string[], visibleInput: ReadonlySet<number> | readonly number[], source?: BlockContextSource): Map<number, string>;
+/**
+ * Build display entries for `visibleSpans` plus any off-window block-boundary
+ * lines, in source order, with `{ kind: "ellipsis" }` markers inserted across
+ * non-contiguous gaps. `options.lineText` lets callers substitute display text
+ * (e.g. column-truncated lines) for a given line number.
+ */
+export declare function buildLineEntriesWithBlockContext(fullLines: readonly string[], visibleSpans: readonly LineSpan[], source?: BlockContextSource, options?: {
+    lineText?: (lineNumber: number, sourceText: string, context: boolean) => string;
+}): LineEntry[];
+export declare function lineEntriesToPlainText(entries: readonly LineEntry[], ellipsis?: string): string;

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

@@ -0,0 +1,33 @@
+export interface ChangelogEntry {
+    major: number;
+    minor: number;
+    patch: number;
+    content: string;
+}
+/**
+ * Parse changelog entries from the file at `changelogPath`. Scans for `## [x.y.z]`
+ * headings and collects each block until the next heading or EOF.
+ *
+ * Returns `[]` when `changelogPath` is `undefined` (package directory not
+ * resolvable — see `getChangelogPath`) or the file is missing. Callers MUST NOT
+ * synthesize a fallback path from the host project's cwd; doing so caused issue
+ * #1423 (the host project's `CHANGELOG.md` was rendered as omp's).
+ */
+export declare function parseChangelog(changelogPath: string | undefined): Promise<ChangelogEntry[]>;
+/**
+ * Compare versions. Returns: -1 if v1 < v2, 0 if v1 === v2, 1 if v1 > v2
+ */
+export declare function compareVersions(v1: ChangelogEntry, v2: ChangelogEntry): number;
+/**
+ * Get entries newer than lastVersion
+ */
+export declare function getNewEntries(entries: ChangelogEntry[], lastVersion: string): ChangelogEntry[];
+export { getChangelogPath } from "../config";
+/**
+ * Last jeopi version whose changelog the user has seen. Stored as a plain-text
+ * marker file (`~/.jeopi/agent/last-changelog-version`) rather than in
+ * `config.yml`, so version bumps never dirty user-tracked config files.
+ */
+export declare function readLastChangelogVersion(agentDir?: string): Promise<string | undefined>;
+/** Persist the last-seen changelog version marker. Best-effort: failures are logged, never thrown. */
+export declare function writeLastChangelogVersion(version: string, agentDir?: string): Promise<void>;

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

@@ -0,0 +1,37 @@
+import type { ClipboardImage } from "jeopi-natives";
+/**
+ * Read file paths from the macOS pasteboard's `public.file-url` representation.
+ *
+ * Used to reach the Finder `Cmd+C` pasteboard (which exposes only file URLs,
+ * no plain text or raw image bytes) so an image-file clipboard can be attached
+ * via {@link handleImagePathPaste} instead of falling through to "Clipboard is
+ * empty". Returns an empty array on non-darwin platforms, when AppleScript is
+ * unavailable, or when the pasteboard holds no file URLs.
+ */
+export declare function readMacFileUrlsFromClipboard(): Promise<string[]>;
+/**
+ * Copy text to the system clipboard.
+ *
+ * Emits OSC 52 first when running in a real terminal (works over SSH/mosh),
+ * then attempts native clipboard copy as best-effort for local sessions.
+ * On Termux, tries `termux-clipboard-set` before native.
+ *
+ * @param text - UTF-8 text to place on the clipboard.
+ */
+export declare function copyToClipboard(text: string): Promise<void>;
+/**
+ * Read an image from the system clipboard.
+ *
+ * Returns null on Termux (no image clipboard support) or when no display
+ * server is available (headless/SSH without forwarding). Under native Windows
+ * and WSL, the Windows clipboard is also reached through `powershell.exe`
+ * because terminal clipboard paths can leave image payloads invisible to the
+ * native bridge.
+ *
+ * @returns PNG payload or null when no image is available.
+ */
+export declare function readImageFromClipboard(): Promise<ClipboardImage | null>;
+/**
+ * Read plain text from the system clipboard.
+ */
+export declare function readTextFromClipboard(): Promise<string>;

package/dist/types/utils/command-args.d.ts

@@ -0,0 +1,9 @@
+export declare function parseCommandArgs(argsString: string): string[];
+/**
+ * Substitute argument placeholders in template content
+ * Supports $1, $2, ... for positional args, $@ and $ARGUMENTS for all args
+ *
+ * Note: Replacement happens on the template string only. Argument values
+ * containing patterns like $1, $@, or $ARGUMENTS are NOT recursively substituted.
+ */
+export declare function substituteArgs(content: string, args: string[]): string;

package/dist/types/utils/commit-message-generator.d.ts

@@ -0,0 +1,7 @@
+import type { ModelRegistry } from "../config/model-registry";
+import type { Settings } from "../config/settings";
+/**
+ * Generate a commit message from a unified diff.
+ * Returns null if generation fails (caller should fall back to generic message).
+ */
+export declare function generateCommitMessage(diff: string, registry: ModelRegistry, settings: Settings, sessionId?: string): Promise<string | null>;

package/dist/types/utils/edit-mode.d.ts

@@ -0,0 +1,13 @@
+export type EditMode = "replace" | "patch" | "hashline" | "apply_patch";
+export declare const DEFAULT_EDIT_MODE: EditMode;
+export declare const EDIT_MODES: EditMode[];
+export declare function normalizeEditMode(mode?: string | null): EditMode | undefined;
+export interface EditModeSettingsLike {
+    get(key: "edit.mode"): unknown;
+    getEditVariantForModel?(model: string | undefined): EditMode | null;
+}
+export interface EditModeSessionLike {
+    settings: EditModeSettingsLike;
+    getActiveModelString?: () => string | undefined;
+}
+export declare function resolveEditMode(session: EditModeSessionLike): EditMode;

package/dist/types/utils/enhanced-paste.d.ts

@@ -0,0 +1,20 @@
+import type { ImageContent } from "jeopi-ai";
+export interface Osc5522Packet {
+    metadata: Map<string, string>;
+    payload: string;
+}
+export interface EnhancedPasteHandlers {
+    write(data: string): void;
+    pasteText(text: string): void;
+    pasteImage(image: ImageContent): void | Promise<void>;
+    showStatus(message: string): void;
+}
+export declare function isOsc5522Packet(data: string): boolean;
+export declare function parseOsc5522Packet(data: string): Osc5522Packet | undefined;
+export declare class EnhancedPasteController {
+    #private;
+    constructor(handlers: EnhancedPasteHandlers);
+    enable(): void;
+    disable(): void;
+    handleInput(data: string): boolean;
+}

package/dist/types/utils/event-bus.d.ts

@@ -0,0 +1,6 @@
+export declare class EventBus {
+    #private;
+    emit(channel: string, data: unknown): void;
+    on(channel: string, handler: (data: unknown) => void): () => void;
+    clear(): void;
+}

package/dist/types/utils/external-editor.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Returns the user's preferred editor command, or a platform default.
+ *
+ * Resolution order:
+ *   1. `$VISUAL`
+ *   2. `$EDITOR`
+ *   3. `notepad` on Windows (always present in `%SystemRoot%\System32`)
+ *
+ * POSIX returns `undefined` when neither variable is set so the caller can
+ * surface a warning that nudges the user to configure one.
+ */
+export declare function getEditorCommand(): string | undefined;
+export interface OpenInEditorOptions {
+    /** File extension for the temp file (default: ".md"). */
+    extension?: string;
+    /** Custom stdio configuration (default: all "inherit"). */
+    stdio?: [number | "inherit", number | "inherit", number | "inherit"];
+    /** Keep the file's trailing newline instead of trimming it from the returned text. */
+    trimTrailingNewline?: boolean;
+}
+/**
+ * Opens `content` in the user's external editor and returns the edited text.
+ * Returns `null` if the editor exits with a non-zero code.
+ *
+ * The caller is responsible for stopping/starting the TUI around this call.
+ */
+export declare function openInEditor(editorCmd: string, content: string, options?: OpenInEditorOptions): Promise<string | null>;

package/dist/types/utils/file-display-mode.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Resolve line-display mode for file-like outputs (read, grep, @file mentions).
+ */
+export interface FileDisplayMode {
+    lineNumbers: boolean;
+    hashLines: boolean;
+}
+/** Session-like object providing settings and tool availability for display mode resolution. */
+export interface FileDisplayModeSession {
+    /** Whether the edit tool is available. Hashlines are suppressed without it. */
+    hasEditTool?: boolean;
+    settings: {
+        get(key: "readLineNumbers" | "edit.mode"): unknown;
+    };
+}
+/**
+ * Computes effective line display mode from session settings/env.
+ * Hashline mode takes precedence and implies line-addressed output everywhere.
+ * Hashlines are suppressed when the edit tool is not available (e.g. explore agents),
+ * when the caller signals a `raw` read, and when the source is `immutable`
+ * (e.g. internal URLs like artifact://, agent://, memory:// — there is no edit
+ * path that could consume the anchors). Raw output is returned as-is.
+ */
+export declare function resolveFileDisplayMode(session: FileDisplayModeSession, options?: {
+    raw?: boolean;
+    immutable?: boolean;
+}): FileDisplayMode;

package/dist/types/utils/file-mentions.d.ts

@@ -0,0 +1,13 @@
+import type { AgentMessage } from "jeopi-agent-core";
+import { type SnapshotStore } from "jeopi-hashline";
+/** Extract all @filepath mentions from text */
+export declare function extractFileMentions(text: string): string[];
+/**
+ * Generate a FileMentionMessage containing the contents of mentioned files.
+ * Returns empty array if no files could be read.
+ */
+export declare function generateFileMentionMessages(filePaths: string[], cwd: string, options?: {
+    autoResizeImages?: boolean;
+    useHashLines?: boolean;
+    snapshotStore?: SnapshotStore;
+}): Promise<AgentMessage[]>;