@sunub/obsidian-mcp-server 0.3.0 → 0.3.2

package/build/cli/key/text-buffer.d.ts

@@ -0,0 +1,509 @@
+import type { Key } from "../context/KeypressContext.js";
+export declare const PASTED_TEXT_PLACEHOLDER_REGEX: RegExp;
+export interface TextBuffer {
+    lines: string[];
+    text: string;
+    cursor: [number, number];
+    /**
+     * When the user moves the caret vertically we try to keep their original
+     * horizontal column even when passing through shorter lines.  We remember
+     * that *preferred* column in this field while the user is still travelling
+     * vertically.  Any explicit horizontal movement resets the preference.
+     */
+    preferredCol: number | null;
+    selectionAnchor: [number, number] | null;
+    pastedContent: Record<string, string>;
+    allVisualLines: string[];
+    viewportVisualLines: string[];
+    visualCursor: [number, number];
+    visualScrollRow: number;
+    viewportHeight: number;
+    /**
+     * For each visual line (by absolute index in allVisualLines) provides a tuple
+     * [logicalLineIndex, startColInLogical] that maps where that visual line
+     * begins within the logical buffer. Indices are code-point based.
+     */
+    visualToLogicalMap: Array<[number, number]>;
+    /**
+     * For each logical line, an array mapping transformed positions (in the transformed
+     * line) back to logical column indices.
+     */
+    transformedToLogicalMaps: number[][];
+    /**
+     * For each visual line (absolute index across all visual lines), the start index
+     * within that logical line's transformed content.
+     */
+    visualToTransformedMap: number[];
+    /** Cached transformations per logical line */
+    visualLayout: VisualLayout;
+    /**
+     * Replaces the entire buffer content with the provided text.
+     * The operation is undoable.
+     */
+    setText: (text: string, cursorPosition?: "start" | "end" | number) => void;
+    /**
+     * Insert a single character or string without newlines.
+     */
+    insert: (ch: string, opts?: {
+        paste?: boolean;
+    }) => void;
+    newline: () => void;
+    backspace: () => void;
+    del: () => void;
+    move: (dir: Direction) => void;
+    undo: () => void;
+    redo: () => void;
+    /**
+     * Replaces the text within the specified range with new text.
+     * Handles both single-line and multi-line ranges.
+     *
+     * @param startRow The starting row index (inclusive).
+     * @param startCol The starting column index (inclusive, code-point based).
+     * @param endRow The ending row index (inclusive).
+     * @param endCol The ending column index (exclusive, code-point based).
+     * @param text The new text to insert.
+     * @returns True if the buffer was modified, false otherwise.
+     */
+    replaceRange: (startRow: number, startCol: number, endRow: number, endCol: number, text: string) => void;
+    /**
+     * Delete the word to the *left* of the caret, mirroring common
+     * Ctrl/Alt+Backspace behaviour in editors & terminals. Both the adjacent
+     * whitespace *and* the word characters immediately preceding the caret are
+     * removed.  If the caret is already at column‑0 this becomes a no-op.
+     */
+    deleteWordLeft: () => void;
+    /**
+     * Delete the word to the *right* of the caret, akin to many editors'
+     * Ctrl/Alt+Delete shortcut.  Removes any whitespace/punctuation that
+     * follows the caret and the next contiguous run of word characters.
+     */
+    deleteWordRight: () => void;
+    /**
+     * Deletes text from the cursor to the end of the current line.
+     */
+    killLineRight: () => void;
+    /**
+     * Deletes text from the start of the current line to the cursor.
+     */
+    killLineLeft: () => void;
+    /**
+     * High level "handleInput" – receives what Ink gives us.
+     */
+    handleInput: (key: Key) => boolean;
+    /**
+     * Opens the current buffer contents in the user's preferred terminal text
+     * editor ($VISUAL or $EDITOR, falling back to "vi").  The method blocks
+     * until the editor exits, then reloads the file and replaces the in‑memory
+     * buffer with whatever the user saved.
+     *
+     * The operation is treated as a single undoable edit – we snapshot the
+     * previous state *once* before launching the editor so one `undo()` will
+     * revert the entire change set.
+     *
+     * Note: We purposefully rely on the *synchronous* spawn API so that the
+     * calling process genuinely waits for the editor to close before
+     * continuing.  This mirrors Git's behaviour and simplifies downstream
+     * control‑flow (callers can simply `await` the Promise).
+     */
+    openInExternalEditor: () => Promise<void>;
+    replaceRangeByOffset: (startOffset: number, endOffset: number, replacementText: string) => void;
+    getOffset: () => number;
+    moveToOffset(offset: number): void;
+    moveToVisualPosition(visualRow: number, visualCol: number): void;
+    /**
+     * Convert visual coordinates to logical position without moving cursor.
+     * Returns null if the position is out of bounds.
+     */
+    getLogicalPositionFromVisual(visualRow: number, visualCol: number): {
+        row: number;
+        col: number;
+    } | null;
+    /**
+     * Check if a line index falls within an expanded paste region.
+     * Returns the paste placeholder ID if found, null otherwise.
+     */
+    getExpandedPasteAtLine(lineIndex: number): string | null;
+    /**
+     * Toggle expansion state for a paste placeholder.
+     * If collapsed, expands to show full content inline.
+     * If expanded, collapses back to placeholder.
+     */
+    togglePasteExpansion(id: string, row: number, col: number): void;
+    /**
+     * The current expanded paste info (read-only).
+     */
+    /**
+     * Delete N words forward from cursor position (vim 'dw' command)
+     */
+    vimDeleteWordForward: (count: number) => void;
+    /**
+     * Delete N words backward from cursor position (vim 'db' command)
+     */
+    vimDeleteWordBackward: (count: number) => void;
+    /**
+     * Delete to end of N words from cursor position (vim 'de' command)
+     */
+    vimDeleteWordEnd: (count: number) => void;
+    /**
+     * Delete N big words forward from cursor position (vim 'dW' command)
+     */
+    vimDeleteBigWordForward: (count: number) => void;
+    /**
+     * Delete N big words backward from cursor position (vim 'dB' command)
+     */
+    vimDeleteBigWordBackward: (count: number) => void;
+    /**
+     * Delete to end of N big words from cursor position (vim 'dE' command)
+     */
+    vimDeleteBigWordEnd: (count: number) => void;
+    /**
+     * Change N words forward from cursor position (vim 'cw' command)
+     */
+    vimChangeWordForward: (count: number) => void;
+    /**
+     * Change N words backward from cursor position (vim 'cb' command)
+     */
+    vimChangeWordBackward: (count: number) => void;
+    /**
+     * Change to end of N words from cursor position (vim 'ce' command)
+     */
+    vimChangeWordEnd: (count: number) => void;
+    /**
+     * Change N big words forward from cursor position (vim 'cW' command)
+     */
+    vimChangeBigWordForward: (count: number) => void;
+    /**
+     * Change N big words backward from cursor position (vim 'cB' command)
+     */
+    vimChangeBigWordBackward: (count: number) => void;
+    /**
+     * Change to end of N big words from cursor position (vim 'cE' command)
+     */
+    vimChangeBigWordEnd: (count: number) => void;
+    /**
+     * Delete N lines from cursor position (vim 'dd' command)
+     */
+    vimDeleteLine: (count: number) => void;
+    /**
+     * Change N lines from cursor position (vim 'cc' command)
+     */
+    vimChangeLine: (count: number) => void;
+    /**
+     * Delete from cursor to end of line (vim 'D' command)
+     * With count > 1, deletes to end of current line plus (count-1) additional lines
+     */
+    vimDeleteToEndOfLine: (count?: number) => void;
+    /**
+     * Delete from start of line to cursor (vim 'd0' command)
+     */
+    vimDeleteToStartOfLine: () => void;
+    /**
+     * Change from cursor to end of line (vim 'C' command)
+     * With count > 1, changes to end of current line plus (count-1) additional lines
+     */
+    vimChangeToEndOfLine: (count?: number) => void;
+    /**
+     * Delete from cursor to first non-whitespace character (vim 'd^' command)
+     */
+    vimDeleteToFirstNonWhitespace: () => void;
+    /**
+     * Change from cursor to start of line (vim 'c0' command)
+     */
+    vimChangeToStartOfLine: () => void;
+    /**
+     * Change from cursor to first non-whitespace character (vim 'c^' command)
+     */
+    vimChangeToFirstNonWhitespace: () => void;
+    /**
+     * Delete from current line to first line (vim 'dgg' command)
+     */
+    vimDeleteToFirstLine: (count: number) => void;
+    /**
+     * Delete from current line to last line (vim 'dG' command)
+     */
+    vimDeleteToLastLine: (count: number) => void;
+    /**
+     * Change movement operations (vim 'ch', 'cj', 'ck', 'cl' commands)
+     */
+    vimChangeMovement: (movement: "h" | "j" | "k" | "l", count: number) => void;
+    /**
+     * Move cursor left N times (vim 'h' command)
+     */
+    vimMoveLeft: (count: number) => void;
+    /**
+     * Move cursor right N times (vim 'l' command)
+     */
+    vimMoveRight: (count: number) => void;
+    /**
+     * Move cursor up N times (vim 'k' command)
+     */
+    vimMoveUp: (count: number) => void;
+    /**
+     * Move cursor down N times (vim 'j' command)
+     */
+    vimMoveDown: (count: number) => void;
+    /**
+     * Move cursor forward N words (vim 'w' command)
+     */
+    vimMoveWordForward: (count: number) => void;
+    /**
+     * Move cursor backward N words (vim 'b' command)
+     */
+    vimMoveWordBackward: (count: number) => void;
+    /**
+     * Move cursor to end of Nth word (vim 'e' command)
+     */
+    vimMoveWordEnd: (count: number) => void;
+    /**
+     * Move cursor forward N big words (vim 'W' command)
+     */
+    vimMoveBigWordForward: (count: number) => void;
+    /**
+     * Move cursor backward N big words (vim 'B' command)
+     */
+    vimMoveBigWordBackward: (count: number) => void;
+    /**
+     * Move cursor to end of Nth big word (vim 'E' command)
+     */
+    vimMoveBigWordEnd: (count: number) => void;
+    /**
+     * Delete N characters at cursor (vim 'x' command)
+     */
+    vimDeleteChar: (count: number) => void;
+    /** Delete N characters before cursor (vim 'X') */
+    vimDeleteCharBefore: (count: number) => void;
+    /** Toggle case of N characters at cursor (vim '~') */
+    vimToggleCase: (count: number) => void;
+    /** Replace N characters at cursor with char, stay in NORMAL mode (vim 'r') */
+    vimReplaceChar: (char: string, count: number) => void;
+    /** Move to Nth occurrence of char forward on line; till=true stops before it (vim 'f'/'t') */
+    vimFindCharForward: (char: string, count: number, till: boolean) => void;
+    /** Move to Nth occurrence of char backward on line; till=true stops after it (vim 'F'/'T') */
+    vimFindCharBackward: (char: string, count: number, till: boolean) => void;
+    /** Delete from cursor to Nth occurrence of char forward; till=true excludes the char (vim 'df'/'dt') */
+    vimDeleteToCharForward: (char: string, count: number, till: boolean) => void;
+    /** Delete from Nth occurrence of char backward to cursor; till=true excludes the char (vim 'dF'/'dT') */
+    vimDeleteToCharBackward: (char: string, count: number, till: boolean) => void;
+    /**
+     * Enter insert mode at cursor (vim 'i' command)
+     */
+    vimInsertAtCursor: () => void;
+    /**
+     * Enter insert mode after cursor (vim 'a' command)
+     */
+    vimAppendAtCursor: () => void;
+    /**
+     * Open new line below and enter insert mode (vim 'o' command)
+     */
+    vimOpenLineBelow: () => void;
+    /**
+     * Open new line above and enter insert mode (vim 'O' command)
+     */
+    vimOpenLineAbove: () => void;
+    /**
+     * Move to end of line and enter insert mode (vim 'A' command)
+     */
+    vimAppendAtLineEnd: () => void;
+    /**
+     * Move to first non-whitespace and enter insert mode (vim 'I' command)
+     */
+    vimInsertAtLineStart: () => void;
+    /**
+     * Move cursor to beginning of line (vim '0' command)
+     */
+    vimMoveToLineStart: () => void;
+    /**
+     * Move cursor to end of line (vim '$' command)
+     */
+    vimMoveToLineEnd: () => void;
+    /**
+     * Move cursor to first non-whitespace character (vim '^' command)
+     */
+    vimMoveToFirstNonWhitespace: () => void;
+    /**
+     * Move cursor to first line (vim 'gg' command)
+     */
+    vimMoveToFirstLine: () => void;
+    /**
+     * Move cursor to last line (vim 'G' command)
+     */
+    vimMoveToLastLine: () => void;
+    /**
+     * Move cursor to specific line number (vim '[N]G' command)
+     */
+    vimMoveToLine: (lineNumber: number) => void;
+    /**
+     * Handle escape from insert mode (moves cursor left if not at line start)
+     */
+    vimEscapeInsertMode: () => void;
+    /** Yank N lines into the unnamed register (vim 'yy' / 'Nyy') */
+    vimYankLine: (count: number) => void;
+    /** Yank forward N words into the unnamed register (vim 'yw') */
+    vimYankWordForward: (count: number) => void;
+    /** Yank forward N big words into the unnamed register (vim 'yW') */
+    vimYankBigWordForward: (count: number) => void;
+    /** Yank to end of N words into the unnamed register (vim 'ye') */
+    vimYankWordEnd: (count: number) => void;
+    /** Yank to end of N big words into the unnamed register (vim 'yE') */
+    vimYankBigWordEnd: (count: number) => void;
+    /** Yank from cursor to end of line into the unnamed register (vim 'y$') */
+    vimYankToEndOfLine: (count: number) => void;
+    /** Paste the unnamed register after cursor (vim 'p') */
+    vimPasteAfter: (count: number) => void;
+    /** Paste the unnamed register before cursor (vim 'P') */
+    vimPasteBefore: (count: number) => void;
+}
+export type Direction = "left" | "right" | "up" | "down" | "home" | "end";
+/**
+ * Visual layout maps logical lines to visual (wrapped) lines.
+ */
+export interface VisualLayout {
+    transformedToLogicalMaps: number[][];
+    visualLines: string[];
+    logicalToVisualMap: Array<Array<[number, number]>>;
+    visualToLogicalMap: Array<[number, number]>;
+    visualToTransformedMap: number[];
+}
+export interface TextBufferState {
+    lines: string[];
+    cursorRow: number;
+    cursorCol: number;
+    preferredCol: number | null;
+    undoStack: string[][];
+    redoStack: string[][];
+    viewportWidth: number;
+    viewportHeight: number;
+    visualScrollRow: number;
+    visualLayout: VisualLayout;
+}
+/**
+ * Helper: Converts logical row/col position to absolute text offset
+ */
+export declare function logicalPosToOffset(lines: string[], row: number, col: number): number;
+/**
+ * Helper: Converts absolute text offset to logical row/col position
+ */
+export declare function offsetToLogicalPos(text: string, offset: number): [number, number];
+export interface Transformation {
+    logStart: number;
+    logEnd: number;
+    logicalText: string;
+    collapsedText: string;
+    type: "image" | "paste";
+    id?: string;
+}
+export declare function calculateTransformationsForLine(line: string): Transformation[];
+export declare function calculateTransformedLine(logLine: string, logIndex: number, logicalCursor: [number, number], transformations: Transformation[]): {
+    transformedLine: string;
+    transformedToLogMap: number[];
+};
+/**
+ * A simplified multi-line text buffer hook with viewport management.
+ */
+export declare function useTextBuffer({ initialText, viewportWidth, viewportHeight, }: {
+    initialText: string;
+    viewportWidth: number;
+    viewportHeight: number;
+}): {
+    lines: string[];
+    text: string;
+    cursor: [number, number];
+    preferredCol: number | null;
+    selectionAnchor: null;
+    pastedContent: {};
+    allVisualLines: string[];
+    viewportVisualLines: string[];
+    visualCursor: [number, number];
+    visualScrollRow: number;
+    viewportHeight: number;
+    visualToLogicalMap: [number, number][];
+    transformedToLogicalMaps: number[][];
+    visualToTransformedMap: number[];
+    visualLayout: VisualLayout;
+    insert: (text: string, opts?: {
+        paste?: boolean;
+    }) => void;
+    setText: (text: string, cursorPosition?: "start" | "end" | number) => void;
+    newline: () => void;
+    backspace: () => void;
+    del: () => void;
+    move: (dir: Direction) => void;
+    undo: () => void;
+    redo: () => void;
+    replaceRange: (startRow: number, startCol: number, endRow: number, endCol: number, text: string) => void;
+    deleteWordLeft: () => void;
+    deleteWordRight: () => void;
+    killLineRight: () => void;
+    killLineLeft: () => void;
+    handleInput: (key: Key) => boolean;
+    getOffset: () => number;
+    openInExternalEditor: () => Promise<void>;
+    replaceRangeByOffset: (_s: number, _e: number, _t: string) => void;
+    moveToOffset: (_offset: number) => void;
+    moveToVisualPosition: (_vr: number, _vc: number) => void;
+    getLogicalPositionFromVisual: (_vr: number, _vc: number) => null;
+    getExpandedPasteAtLine: (_lineIndex: number) => null;
+    togglePasteExpansion: (_id: string, _row: number, _col: number) => void;
+    vimDeleteWordForward: (_count: number) => void;
+    vimDeleteWordBackward: (_count: number) => void;
+    vimDeleteWordEnd: (_count: number) => void;
+    vimDeleteBigWordForward: (_count: number) => void;
+    vimDeleteBigWordBackward: (_count: number) => void;
+    vimDeleteBigWordEnd: (_count: number) => void;
+    vimChangeWordForward: (_count: number) => void;
+    vimChangeWordBackward: (_count: number) => void;
+    vimChangeWordEnd: (_count: number) => void;
+    vimChangeBigWordForward: (_count: number) => void;
+    vimChangeBigWordBackward: (_count: number) => void;
+    vimChangeBigWordEnd: (_count: number) => void;
+    vimDeleteLine: (_count: number) => void;
+    vimChangeLine: (_count: number) => void;
+    vimDeleteToEndOfLine: (_count?: number) => void;
+    vimDeleteToStartOfLine: () => void;
+    vimChangeToEndOfLine: (_count?: number) => void;
+    vimDeleteToFirstNonWhitespace: () => void;
+    vimChangeToStartOfLine: () => void;
+    vimChangeToFirstNonWhitespace: () => void;
+    vimDeleteToFirstLine: (_count: number) => void;
+    vimDeleteToLastLine: (_count: number) => void;
+    vimChangeMovement: (_m: "h" | "j" | "k" | "l", _count: number) => void;
+    vimMoveLeft: (_count: number) => void;
+    vimMoveRight: (_count: number) => void;
+    vimMoveUp: (_count: number) => void;
+    vimMoveDown: (_count: number) => void;
+    vimMoveWordForward: (_count: number) => void;
+    vimMoveWordBackward: (_count: number) => void;
+    vimMoveWordEnd: (_count: number) => void;
+    vimMoveBigWordForward: (_count: number) => void;
+    vimMoveBigWordBackward: (_count: number) => void;
+    vimMoveBigWordEnd: (_count: number) => void;
+    vimDeleteChar: (_count: number) => void;
+    vimDeleteCharBefore: (_count: number) => void;
+    vimToggleCase: (_count: number) => void;
+    vimReplaceChar: (_char: string, _count: number) => void;
+    vimFindCharForward: (_char: string, _count: number, _till: boolean) => void;
+    vimFindCharBackward: (_char: string, _count: number, _till: boolean) => void;
+    vimDeleteToCharForward: (_char: string, _count: number, _till: boolean) => void;
+    vimDeleteToCharBackward: (_char: string, _count: number, _till: boolean) => void;
+    vimInsertAtCursor: () => void;
+    vimAppendAtCursor: () => void;
+    vimOpenLineBelow: () => void;
+    vimOpenLineAbove: () => void;
+    vimAppendAtLineEnd: () => void;
+    vimInsertAtLineStart: () => void;
+    vimMoveToLineStart: () => void;
+    vimMoveToLineEnd: () => void;
+    vimMoveToFirstNonWhitespace: () => void;
+    vimMoveToFirstLine: () => void;
+    vimMoveToLastLine: () => void;
+    vimMoveToLine: (_count: number) => void;
+    vimEscapeInsertMode: () => void;
+    vimYankLine: (_count: number) => void;
+    vimYankWordForward: (_count: number) => void;
+    vimYankBigWordForward: (_count: number) => void;
+    vimYankWordEnd: (_count: number) => void;
+    vimYankBigWordEnd: (_count: number) => void;
+    vimYankToEndOfLine: (_count: number) => void;
+    vimPasteAfter: (_count: number) => void;
+    vimPasteBefore: (_count: number) => void;
+};

package/build/cli/main.d.ts

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

package/build/cli/main.js

@@ -0,0 +1,20 @@
+process.on("uncaughtException", (error) => {
+    if (process.platform === "win32" &&
+        error instanceof Error &&
+        error.message === "Cannot resize a pty that has already exited.") {
+        // This error happens on Windows with node-pty when resizing a pty that has just exited.
+        // It is a race condition in node-pty that we cannot prevent, so we silence it.
+        return;
+    }
+    if (error instanceof Error) {
+        process.stderr.write(`${error.stack} + '\n'`);
+    }
+    else {
+        process.stderr.write(`${error} + '\n'`);
+    }
+    process.exit(1);
+});
+async function run() { }
+run();
+export {};
+//# sourceMappingURL=main.js.map

package/build/cli/main.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"main.js","sourceRoot":"","sources":["../../src/cli/main.ts"],"names":[],"mappings":"AAAA,OAAO,CAAC,EAAE,CAAC,mBAAmB,EAAE,CAAC,KAAK,EAAE,EAAE;IACzC,IACC,OAAO,CAAC,QAAQ,KAAK,OAAO;QAC5B,KAAK,YAAY,KAAK;QACtB,KAAK,CAAC,OAAO,KAAK,8CAA8C,EAC/D,CAAC;QACF,wFAAwF;QACxF,+EAA+E;QAC/E,OAAO;IACR,CAAC;IAED,IAAI,KAAK,YAAY,KAAK,EAAE,CAAC;QAC5B,OAAO,CAAC,MAAM,CAAC,KAAK,CAAC,GAAG,KAAK,CAAC,KAAK,SAAS,CAAC,CAAC;IAC/C,CAAC;SAAM,CAAC;QACP,OAAO,CAAC,MAAM,CAAC,KAAK,CAAC,GAAG,KAAK,SAAS,CAAC,CAAC;IACzC,CAAC;IACD,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;AACjB,CAAC,CAAC,CAAC;AAEH,KAAK,UAAU,GAAG,KAAI,CAAC;AAEvB,GAAG,EAAE,CAAC"}