vibeman 0.0.0 → 0.0.2

package/dist/runtime/api/lib/server/agent-service-singleton.js

@@ -0,0 +1,27 @@
+import { AgentService } from '../../agent/agent-service.js';
+import { getTaskService } from './task-service-singleton.js';
+import { getSettingsService } from '../../settings-service.js';
+import { getProjectRoot, getVibeDir } from './project-root.js';
+export function getAgentService() {
+    if (!globalThis.__vibeman_agent_service__) {
+        const taskService = getTaskService();
+        const settingsVibeDir = (() => {
+            try {
+                const svc = getSettingsService();
+                const s = svc.getSettings();
+                return s?.development?.vibeDir;
+            }
+            catch {
+                return undefined;
+            }
+        })();
+        const projectRoot = getProjectRoot();
+        const vibeDir = settingsVibeDir || getVibeDir();
+        globalThis.__vibeman_agent_service__ = new AgentService(taskService, projectRoot);
+        console.log(`🤖 Agent Service initialized (projectRoot=${projectRoot}, vibeDir=${vibeDir})`);
+    }
+    return globalThis.__vibeman_agent_service__;
+}
+export function resetAgentService() {
+    globalThis.__vibeman_agent_service__ = undefined;
+}

package/dist/runtime/api/lib/server/bootstrap.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Server Bootstrap - Async-first service initialization
+ *
+ * Provides ordered initialization of core services before router creation,
+ * ensuring all dependencies are ready for synchronous access during runtime.
+ */
+import { getSettingsService } from '../../settings-service.js';
+import { TaskService } from '../../tasks/task-service.js';
+import { AgentService } from '../../agent/agent-service.js';
+import { GitService } from '../../vcs/git-service.js';
+import { WorktreeService } from '../../vcs/worktree-service.js';
+import { VibingOrchestrator } from '../../workflows/vibing-orchestrator.js';
+/**
+ * Initialize core services in proper dependency order.
+ * Must be called before any service getters or router creation.
+ */
+export declare function bootstrap(): Promise<void>;
+/**
+ * Ready-only sync getters - throw if called before bootstrap
+ */
+export declare function getBootstrappedSettingsService(): ReturnType<typeof getSettingsService>;
+export declare function getBootstrappedTaskService(): TaskService;
+export declare function getBootstrappedAgentService(): AgentService;
+export declare function getBootstrappedGitService(): GitService;
+export declare function getBootstrappedWorktreeService(): WorktreeService;
+export declare function getBootstrappedVibingOrchestrator(): VibingOrchestrator;
+/**
+ * Get bootstrap completion promise for diagnostics/tests
+ */
+export declare function getBootstrapReady(): Promise<void> | null;
+/**
+ * Check if bootstrap has completed
+ */
+export declare function isBootstrapComplete(): boolean;
+/**
+ * Test bootstrap function that initializes against a temp workspace
+ */
+export declare function testBootstrap(tempWorkspace?: string): Promise<void>;

package/dist/runtime/api/lib/server/bootstrap.js

@@ -0,0 +1,197 @@
+/**
+ * Server Bootstrap - Async-first service initialization
+ *
+ * Provides ordered initialization of core services before router creation,
+ * ensuring all dependencies are ready for synchronous access during runtime.
+ */
+import { log } from '../logger.js';
+import { getSettingsService } from '../../settings-service.js';
+import { TaskService } from '../../tasks/task-service.js';
+import { AgentService } from '../../agent/agent-service.js';
+import { GitService } from '../../vcs/git-service.js';
+import { VibingOrchestrator } from '../../workflows/vibing-orchestrator.js';
+import { getProjectRoot, getVibeDir } from './project-root.js';
+// Ready-only service instances - throw if accessed before bootstrap
+let settingsService = null;
+let taskService = null;
+let agentService = null;
+let gitService = null;
+let worktreeService = null;
+let vibingOrchestrator = null;
+// Bootstrap completion promise for diagnostics/tests
+let ready = null;
+let isBootstrapped = false;
+// Default config fallback for VibingOrchestrator
+const getDefaultVibingConfig = () => ({
+    autoQualityChecks: true,
+    requireHumanApproval: true,
+    aiCodeReview: true,
+    retryPolicy: { maxImplementationAttempts: 3 },
+    autoCommit: false,
+});
+/**
+ * Initialize core services in proper dependency order.
+ * Must be called before any service getters or router creation.
+ */
+export async function bootstrap() {
+    if (isBootstrapped) {
+        log.info('Bootstrap already completed, skipping');
+        return;
+    }
+    if (ready) {
+        log.info('Bootstrap already in progress, waiting...');
+        return ready;
+    }
+    const startTime = Date.now();
+    log.info('Starting server bootstrap', {}, 'bootstrap');
+    ready = (async () => {
+        try {
+            // Stage 1: Settings Service (foundation)
+            const settingsStart = Date.now();
+            settingsService = getSettingsService();
+            log.info('Settings service initialized', {
+                duration: Date.now() - settingsStart,
+            }, 'bootstrap');
+            // Stage 2: Task Service (depends on settings for vibeDir)
+            const taskStart = Date.now();
+            const settingsVibeDir = (() => {
+                try {
+                    const s = settingsService.getSettings();
+                    return s?.development?.vibeDir;
+                }
+                catch {
+                    return undefined;
+                }
+            })();
+            const vibeDir = settingsVibeDir ?? getVibeDir();
+            taskService = new TaskService(vibeDir);
+            await taskService.ensureInitialized();
+            log.info('Task service initialized', {
+                vibeDir,
+                duration: Date.now() - taskStart,
+            }, 'bootstrap');
+            // Stage 3: Git Service (independent)
+            const gitStart = Date.now();
+            const projectRoot = getProjectRoot();
+            const settingsDefaultBranch = (() => {
+                try {
+                    const s = settingsService.getSettings();
+                    return s?.development?.git?.defaultBranch;
+                }
+                catch {
+                    return undefined;
+                }
+            })();
+            const gitConfig = {
+                defaultBranch: settingsDefaultBranch || 'main',
+            };
+            gitService = new GitService(projectRoot, gitConfig);
+            log.info('Git service initialized', {
+                projectRoot,
+                defaultBranch: gitConfig.defaultBranch,
+                duration: Date.now() - gitStart,
+            }, 'bootstrap');
+            // Stage 4: Agent Service (depends on task service)
+            const agentStart = Date.now();
+            agentService = new AgentService(taskService, projectRoot);
+            log.info('Agent service initialized', {
+                duration: Date.now() - agentStart,
+            }, 'bootstrap');
+            // Stage 5: Worktree Service (depends on git service, settings)
+            const worktreeStart = Date.now();
+            worktreeService = agentService.getWorktreeService();
+            await worktreeService.initialize();
+            log.info('Worktree service initialized', {
+                duration: Date.now() - worktreeStart,
+            }, 'bootstrap');
+            // Stage 6: VibingOrchestrator (depends on all previous services)
+            const orchestratorStart = Date.now();
+            vibingOrchestrator = new VibingOrchestrator(taskService, agentService, worktreeService, getDefaultVibingConfig(), gitService);
+            await vibingOrchestrator.initialize();
+            log.info('VibingOrchestrator initialized', {
+                duration: Date.now() - orchestratorStart,
+            }, 'bootstrap');
+            isBootstrapped = true;
+            const totalDuration = Date.now() - startTime;
+            log.info('Server bootstrap completed', {
+                totalDuration,
+                stages: 6,
+            }, 'bootstrap');
+        }
+        catch (error) {
+            log.error('Server bootstrap failed', error, 'bootstrap');
+            throw error;
+        }
+    })();
+    return ready;
+}
+/**
+ * Ready-only sync getters - throw if called before bootstrap
+ */
+export function getBootstrappedSettingsService() {
+    if (!settingsService) {
+        throw new Error('Settings service not available - bootstrap() must be called first');
+    }
+    return settingsService;
+}
+export function getBootstrappedTaskService() {
+    if (!taskService) {
+        throw new Error('Task service not available - bootstrap() must be called first');
+    }
+    return taskService;
+}
+export function getBootstrappedAgentService() {
+    if (!agentService) {
+        throw new Error('Agent service not available - bootstrap() must be called first');
+    }
+    return agentService;
+}
+export function getBootstrappedGitService() {
+    if (!gitService) {
+        throw new Error('Git service not available - bootstrap() must be called first');
+    }
+    return gitService;
+}
+export function getBootstrappedWorktreeService() {
+    if (!worktreeService) {
+        throw new Error('Worktree service not available - bootstrap() must be called first');
+    }
+    return worktreeService;
+}
+export function getBootstrappedVibingOrchestrator() {
+    if (!vibingOrchestrator) {
+        throw new Error('VibingOrchestrator not available - bootstrap() must be called first');
+    }
+    return vibingOrchestrator;
+}
+/**
+ * Get bootstrap completion promise for diagnostics/tests
+ */
+export function getBootstrapReady() {
+    return ready;
+}
+/**
+ * Check if bootstrap has completed
+ */
+export function isBootstrapComplete() {
+    return isBootstrapped;
+}
+/**
+ * Test bootstrap function that initializes against a temp workspace
+ */
+export async function testBootstrap(tempWorkspace) {
+    // Reset bootstrap state for testing
+    settingsService = null;
+    taskService = null;
+    agentService = null;
+    gitService = null;
+    worktreeService = null;
+    vibingOrchestrator = null;
+    ready = null;
+    isBootstrapped = false;
+    // TODO: Implement temp workspace logic if needed
+    if (tempWorkspace) {
+        log.info('Test bootstrap with temp workspace', { tempWorkspace }, 'bootstrap');
+    }
+    return bootstrap();
+}

package/dist/runtime/api/lib/server/git-service-singleton.d.ts

@@ -0,0 +1,6 @@
+import { GitService, GitConfig } from '../../vcs/git-service.js';
+declare global {
+    var __vibeman_git_service__: unknown;
+}
+export declare function getGitService(config?: GitConfig): GitService;
+export declare function resetGitService(): void;

package/dist/runtime/api/lib/server/git-service-singleton.js

@@ -0,0 +1,47 @@
+import { GitService } from '../../vcs/git-service.js';
+import { getSettingsService } from '../../settings-service.js';
+import { getProjectRoot, getVibeDir } from './project-root.js';
+export function getGitService(config) {
+    if (!globalThis.__vibeman_git_service__) {
+        // Resolve project root robustly (handles being launched from apps/api)
+        const projectRoot = getProjectRoot();
+        // Get vibeDir from settings, fallback to detected project .vibeman
+        const settingsVibeDir = (() => {
+            try {
+                const svc = getSettingsService();
+                const s = svc.getSettings();
+                return s?.development?.vibeDir;
+            }
+            catch {
+                return undefined;
+            }
+        })();
+        const vibeDir = settingsVibeDir || getVibeDir();
+        // Prefer settings default branch; fall back to 'main'
+        const settingsDefaultBranch = (() => {
+            try {
+                const svc = getSettingsService();
+                // Best effort; initialize may not have been awaited here
+                // but service returns defaults if not yet loaded from disk
+                const s = svc.getSettings();
+                return s?.development?.git?.defaultBranch;
+            }
+            catch {
+                return undefined;
+            }
+        })();
+        const envConfig = {
+            defaultBranch: settingsDefaultBranch || 'main',
+        };
+        globalThis.__vibeman_git_service__ = new GitService(projectRoot, {
+            ...envConfig,
+            ...config,
+        });
+        const settingsInfo = { defaultBranch: envConfig.defaultBranch };
+        console.log(`🔧 Git Service initialized (root=${projectRoot}, vibeDir=${vibeDir}, defaultBranch=${settingsInfo.defaultBranch})`);
+    }
+    return globalThis.__vibeman_git_service__;
+}
+export function resetGitService() {
+    globalThis.__vibeman_git_service__ = undefined;
+}

package/dist/runtime/api/lib/server/project-root.d.ts

@@ -0,0 +1,2 @@
+export declare function getProjectRoot(): string;
+export declare function getVibeDir(): string;

package/dist/runtime/api/lib/server/project-root.js

@@ -0,0 +1,61 @@
+import fs from 'fs';
+import path from 'path';
+// Find the repository project root by walking up from CWD
+// Preference order:
+// - env VIBEMAN_PROJECT_ROOT
+// - nearest directory containing .git or .vibeman
+// - fallback to process.cwd()
+export function getProjectRoot() {
+    const envRoot = process.env.VIBEMAN_PROJECT_ROOT;
+    if (envRoot && envRoot.trim().length > 0) {
+        const trimmedRoot = envRoot.trim();
+        if (path.isAbsolute(trimmedRoot)) {
+            return path.normalize(trimmedRoot);
+        }
+        const baseCandidates = [
+            process.env.VIBEMAN_PROJECT_ROOT_BASE,
+            process.env.INIT_CWD,
+            process.env.PWD,
+            process.cwd(),
+        ].filter((candidate) => !!candidate && candidate.trim().length > 0);
+        let fallbackResolved = null;
+        for (const base of baseCandidates) {
+            const resolved = path.resolve(base, trimmedRoot);
+            if (!fallbackResolved) {
+                fallbackResolved = resolved;
+            }
+            if (fs.existsSync(resolved)) {
+                return resolved;
+            }
+        }
+        if (fallbackResolved) {
+            return fallbackResolved;
+        }
+        return path.resolve(trimmedRoot);
+    }
+    // First preference: directory that contains a .git directory/file
+    let dir = process.cwd();
+    const { root } = path.parse(dir);
+    while (true) {
+        if (fs.existsSync(path.join(dir, '.git'))) {
+            return dir;
+        }
+        if (dir === root)
+            break;
+        dir = path.dirname(dir);
+    }
+    // Fallback: nearest directory with .vibeman (if repo is checked out without .git, e.g. tarball)
+    dir = process.cwd();
+    while (true) {
+        if (fs.existsSync(path.join(dir, '.vibeman'))) {
+            return dir;
+        }
+        if (dir === root)
+            break;
+        dir = path.dirname(dir);
+    }
+    return process.cwd();
+}
+export function getVibeDir() {
+    return path.join(getProjectRoot(), '.vibeman');
+}

package/dist/runtime/api/lib/server/task-service-singleton.d.ts

@@ -0,0 +1,7 @@
+import { TaskService } from '../../tasks/task-service.js';
+declare global {
+    var __vibeman_task_service__: unknown;
+    var __vibeman_task_service_init__: unknown;
+}
+export declare function getTaskService(): TaskService;
+export declare function getTaskServiceAsync(): Promise<TaskService>;

package/dist/runtime/api/lib/server/task-service-singleton.js

@@ -0,0 +1,58 @@
+import { getSettingsService } from '../../settings-service.js';
+import { TaskService } from '../../tasks/task-service.js';
+import { isProduction } from '../../utils/env.js';
+import { getVibeDir } from './project-root.js';
+export function getTaskService() {
+    if (!globalThis.__vibeman_task_service__) {
+        const settingsVibeDir = (() => {
+            try {
+                const svc = getSettingsService();
+                const s = svc.getSettings();
+                return s?.development?.vibeDir;
+            }
+            catch {
+                return undefined;
+            }
+        })();
+        // Ensure we use the repo-level .vibeman even when launched from a subpackage
+        const vibeDir = settingsVibeDir ?? getVibeDir();
+        globalThis.__vibeman_task_service__ = new TaskService(vibeDir);
+        console.log(`🗂️ Task Service initialized (vibeDir=${vibeDir})`);
+        globalThis.__vibeman_task_service__
+            .ensureInitialized()
+            .catch((e) => console.error('TaskService init error:', e));
+    }
+    return globalThis.__vibeman_task_service__;
+}
+export async function getTaskServiceAsync() {
+    if (globalThis.__vibeman_task_service__) {
+        return globalThis.__vibeman_task_service__;
+    }
+    if (!globalThis.__vibeman_task_service_init__) {
+        const settingsVibeDir = (() => {
+            try {
+                const svc = getSettingsService();
+                const s = svc.getSettings();
+                return s?.development?.vibeDir;
+            }
+            catch {
+                return undefined;
+            }
+        })();
+        const vibeDir = settingsVibeDir ?? getVibeDir();
+        globalThis.__vibeman_task_service__ = new TaskService(vibeDir);
+        globalThis.__vibeman_task_service_init__ = globalThis.__vibeman_task_service__
+            .initialize()
+            .then(() => globalThis.__vibeman_task_service__);
+    }
+    return globalThis.__vibeman_task_service_init__;
+}
+// Cleanup on process exit
+if (isProduction()) {
+    process.on('SIGTERM', () => {
+        if (globalThis.__vibeman_task_service__) {
+            globalThis.__vibeman_task_service__.stop();
+            globalThis.__vibeman_task_service__ = undefined;
+        }
+    });
+}

package/dist/runtime/api/lib/server/vibing-orchestrator-singleton.d.ts

@@ -0,0 +1,7 @@
+import { VibingOrchestrator } from '../../workflows/vibing-orchestrator.js';
+declare global {
+    var __vibeman_vibing_orchestrator__: unknown;
+    var __vibeman_vibing_orchestrator_init__: unknown;
+}
+export declare function getVibingOrchestrator(): VibingOrchestrator;
+export declare function getVibingOrchestratorAsync(): Promise<VibingOrchestrator>;

package/dist/runtime/api/lib/server/vibing-orchestrator-singleton.js

@@ -0,0 +1,57 @@
+import { VibingOrchestrator } from '../../workflows/vibing-orchestrator.js';
+import { getTaskService } from './task-service-singleton.js';
+import { getAgentService } from './agent-service-singleton.js';
+import { getGitService } from './git-service-singleton.js';
+import { isProduction } from '../../utils/env.js';
+// Default config fallback for VibingOrchestrator
+const getDefaultVibingConfig = () => ({
+    autoQualityChecks: true,
+    requireHumanApproval: true,
+    aiCodeReview: true,
+    retryPolicy: { maxImplementationAttempts: 3 },
+    autoCommit: false,
+});
+export function getVibingOrchestrator() {
+    if (!globalThis.__vibeman_vibing_orchestrator__) {
+        const taskService = getTaskService();
+        const agentService = getAgentService();
+        const gitService = getGitService();
+        globalThis.__vibeman_vibing_orchestrator__ = new VibingOrchestrator(taskService, agentService, agentService.getWorktreeService(), getDefaultVibingConfig(), gitService);
+    }
+    // Kick off one-time initialization in background (non-blocking)
+    if (!globalThis.__vibeman_vibing_orchestrator_init__) {
+        globalThis.__vibeman_vibing_orchestrator_init__ = globalThis.__vibeman_vibing_orchestrator__
+            .initialize()
+            .catch((e) => console.error('VibingOrchestrator init error:', e))
+            .finally(() => {
+            globalThis.__vibeman_vibing_orchestrator_init__ = undefined;
+        });
+    }
+    return globalThis.__vibeman_vibing_orchestrator__;
+}
+export async function getVibingOrchestratorAsync() {
+    if (globalThis.__vibeman_vibing_orchestrator__) {
+        return globalThis.__vibeman_vibing_orchestrator__;
+    }
+    if (!globalThis.__vibeman_vibing_orchestrator_init__) {
+        const taskService = getTaskService();
+        const agentService = getAgentService();
+        const gitService = getGitService();
+        globalThis.__vibeman_vibing_orchestrator__ = new VibingOrchestrator(taskService, agentService, agentService.getWorktreeService(), getDefaultVibingConfig(), gitService);
+        globalThis.__vibeman_vibing_orchestrator_init__ = globalThis.__vibeman_vibing_orchestrator__
+            .initialize()
+            .catch((e) => console.error('VibingOrchestrator init error:', e));
+    }
+    await globalThis.__vibeman_vibing_orchestrator_init__;
+    return globalThis.__vibeman_vibing_orchestrator__;
+}
+// Cleanup on process exit
+if (isProduction()) {
+    process.on('SIGTERM', () => {
+        if (globalThis.__vibeman_vibing_orchestrator__) {
+            // VibingOrchestrator doesn't have a stop method, but we can clean up the reference
+            globalThis.__vibeman_vibing_orchestrator__ = undefined;
+            globalThis.__vibeman_vibing_orchestrator_init__ = undefined;
+        }
+    });
+}

package/dist/runtime/api/lib/tiptap-utils.clamp-selection.test.d.ts

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

package/dist/runtime/api/lib/tiptap-utils.clamp-selection.test.js

@@ -0,0 +1,27 @@
+import { describe, it, expect } from 'vitest';
+import { clampSelectionPos } from './tiptap-utils.js';
+describe('clampSelectionPos', () => {
+    it('keeps positions within valid range', () => {
+        const res = clampSelectionPos(5, 8, 20);
+        expect(res).toEqual({ from: 5, to: 8 });
+    });
+    it('clamps underflow to 1', () => {
+        const res = clampSelectionPos(-10, 0, 20);
+        expect(res).toEqual({ from: 1, to: 1 });
+    });
+    it('clamps overflow to doc.nodeSize - 2', () => {
+        const res = clampSelectionPos(100, 200, 20);
+        // maxPos = 18 for nodeSize 20
+        expect(res).toEqual({ from: 18, to: 18 });
+    });
+    it('orders from/to when anchor > head', () => {
+        const res = clampSelectionPos(10, 5, 20);
+        expect(res).toEqual({ from: 5, to: 10 });
+    });
+    it('handles tiny documents safely', () => {
+        const res0 = clampSelectionPos(5, 6, 0);
+        expect(res0).toEqual({ from: 1, to: 1 });
+        const res1 = clampSelectionPos(2, 3, 1);
+        expect(res1).toEqual({ from: 1, to: 1 });
+    });
+});

package/dist/runtime/api/lib/tiptap-utils.d.ts

@@ -0,0 +1,130 @@
+import type { Node as TiptapNode } from '@tiptap/pm/model';
+import type { Editor } from '@tiptap/react';
+export declare const MAX_FILE_SIZE: number;
+export declare const MAC_SYMBOLS: Record<string, string>;
+export declare function cn(...classes: (string | boolean | undefined | null)[]): string;
+/**
+ * Determines if the current platform is macOS
+ * @returns boolean indicating if the current platform is Mac
+ */
+export declare function isMac(): boolean;
+/**
+ * Formats a shortcut key based on the platform (Mac or non-Mac)
+ * @param key - The key to format (e.g., "ctrl", "alt", "shift")
+ * @param isMac - Boolean indicating if the platform is Mac
+ * @param capitalize - Whether to capitalize the key (default: true)
+ * @returns Formatted shortcut key symbol
+ */
+export declare const formatShortcutKey: (key: string, isMac: boolean, capitalize?: boolean) => string;
+/**
+ * Parses a shortcut key string into an array of formatted key symbols
+ * @param shortcutKeys - The string of shortcut keys (e.g., "ctrl-alt-shift")
+ * @param delimiter - The delimiter used to split the keys (default: "-")
+ * @param capitalize - Whether to capitalize the keys (default: true)
+ * @returns Array of formatted shortcut key symbols
+ */
+export declare const parseShortcutKeys: (props: {
+    shortcutKeys: string | undefined;
+    delimiter?: string;
+    capitalize?: boolean;
+}) => string[];
+/**
+ * Checks if a mark exists in the editor schema
+ * @param markName - The name of the mark to check
+ * @param editor - The editor instance
+ * @returns boolean indicating if the mark exists in the schema
+ */
+export declare const isMarkInSchema: (markName: string, editor: Editor | null) => boolean;
+/**
+ * Checks if a node exists in the editor schema
+ * @param nodeName - The name of the node to check
+ * @param editor - The editor instance
+ * @returns boolean indicating if the node exists in the schema
+ */
+export declare const isNodeInSchema: (nodeName: string, editor: Editor | null) => boolean;
+/**
+ * Moves the focus to the next node in the editor
+ * @param editor - The editor instance
+ * @returns boolean indicating if the focus was moved
+ */
+export declare function focusNextNode(editor: Editor): boolean;
+/**
+ * Checks if a value is a valid number (not null, undefined, or NaN)
+ * @param value - The value to check
+ * @returns boolean indicating if the value is a valid number
+ */
+export declare function isValidPosition(pos: number | null | undefined): pos is number;
+/**
+ * Checks if one or more extensions are registered in the Tiptap editor.
+ * @param editor - The Tiptap editor instance
+ * @param extensionNames - A single extension name or an array of names to check
+ * @returns True if at least one of the extensions is available, false otherwise
+ */
+export declare function isExtensionAvailable(editor: Editor | null, extensionNames: string | string[]): boolean;
+/**
+ * Finds a node at the specified position with error handling
+ * @param editor The Tiptap editor instance
+ * @param position The position in the document to find the node
+ * @returns The node at the specified position, or null if not found
+ */
+export declare function findNodeAtPosition(editor: Editor, position: number): TiptapNode | null;
+/**
+ * Finds the position and instance of a node in the document
+ * @param props Object containing editor, node (optional), and nodePos (optional)
+ * @param props.editor The Tiptap editor instance
+ * @param props.node The node to find (optional if nodePos is provided)
+ * @param props.nodePos The position of the node to find (optional if node is provided)
+ * @returns An object with the position and node, or null if not found
+ */
+export declare function findNodePosition(props: {
+    editor: Editor | null;
+    node?: TiptapNode | null;
+    nodePos?: number | null;
+}): {
+    pos: number;
+    node: TiptapNode;
+} | null;
+/**
+ * Checks if the current selection in the editor is a node selection of specified types
+ * @param editor The Tiptap editor instance
+ * @param types An array of node type names to check against
+ * @returns boolean indicating if the selected node matches any of the specified types
+ */
+export declare function isNodeTypeSelected(editor: Editor | null, types?: string[]): boolean;
+/**
+ * Handles image upload with progress tracking and abort capability
+ * @param file The file to upload
+ * @param onProgress Optional callback for tracking upload progress
+ * @param abortSignal Optional AbortSignal for cancelling the upload
+ * @returns Promise resolving to the URL of the uploaded image
+ */
+export declare const handleImageUpload: (file: File, onProgress?: (_event: {
+    progress: number;
+}) => void, abortSignal?: AbortSignal) => Promise<string>;
+type ProtocolOptions = {
+    /**
+     * The protocol scheme to be registered.
+     * @default '''
+     * @example 'ftp'
+     * @example 'git'
+     */
+    scheme: string;
+    /**
+     * If enabled, it allows optional slashes after the protocol.
+     * @default false
+     * @example true
+     */
+    optionalSlashes?: boolean;
+};
+type ProtocolConfig = Array<ProtocolOptions | string>;
+export declare function isAllowedUri(uri: string | undefined, protocols?: ProtocolConfig): true | RegExpMatchArray | null;
+export declare function sanitizeUrl(inputUrl: string, baseUrl: string, protocols?: ProtocolConfig): string;
+/**
+ * Clamps selection anchor/head to valid [1, doc.nodeSize-2] range.
+ * Returns an object compatible with TipTap's setTextSelection input.
+ */
+export declare function clampSelectionPos(anchor: number, head: number, docNodeSize: number): {
+    from: number;
+    to: number;
+};
+export {};