@getlore/cli 0.2.0

package/dist/tui/browse-handlers-extensions.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Extension handlers for the Lore Document Browser TUI
+ *
+ * Handles extension listing and display.
+ */
+import type { BrowserState, UIComponents } from './browse-types.js';
+/**
+ * Show the extensions list view
+ */
+export declare function showExtensions(state: BrowserState, ui: UIComponents): Promise<void>;
+/**
+ * Update extension selection and refresh display
+ */
+export declare function selectExtension(state: BrowserState, ui: UIComponents): void;
+/**
+ * Toggle the selected extension's enabled state
+ */
+export declare function toggleExtension(state: BrowserState, ui: UIComponents): Promise<void>;

package/dist/tui/browse-handlers-extensions.js

@@ -0,0 +1,107 @@
+/**
+ * Extension handlers for the Lore Document Browser TUI
+ *
+ * Handles extension listing and display.
+ */
+import { renderExtensionsList, renderExtensionDetails } from './browse-render-extensions.js';
+import { getExtensionRegistry } from '../extensions/registry.js';
+import { loadExtensionConfig, addExtensionToConfig } from '../extensions/config.js';
+/**
+ * Show the extensions list view
+ */
+export async function showExtensions(state, ui) {
+    state.mode = 'extensions';
+    ui.fullViewPane.hide();
+    ui.listPane.show();
+    ui.previewPane.show();
+    ui.listTitle.setContent(' Extensions');
+    ui.previewTitle.setContent(' Extension Details');
+    ui.footer.setContent(' j/k: navigate  Enter: toggle  Esc: back');
+    ui.statusBar.setContent(' Loading extensions...');
+    ui.screen.render();
+    try {
+        const registry = await getExtensionRegistry();
+        const config = await loadExtensionConfig();
+        const loaded = registry.listExtensions();
+        // Build extension info list
+        const extensionsList = loaded.map((ext) => {
+            const configEntry = config.extensions.find((e) => e.name === ext.packageName);
+            const hooks = [];
+            if (ext.extension.hooks?.onSourceCreated)
+                hooks.push('onSourceCreated');
+            if (ext.extension.hooks?.onResearchCompleted)
+                hooks.push('onResearchCompleted');
+            if (ext.extension.hooks?.onSyncCompleted)
+                hooks.push('onSyncCompleted');
+            const middleware = (ext.extension.middleware || []).map((m) => m.name);
+            const commands = (ext.extension.commands || []).map((c) => c.name);
+            return {
+                name: ext.extension.name,
+                version: ext.extension.version,
+                packageName: ext.packageName,
+                enabled: configEntry?.enabled !== false,
+                hooks,
+                middleware,
+                commands,
+                permissions: ext.extension.permissions,
+            };
+        });
+        // Also include disabled extensions from config that aren't loaded
+        for (const configEntry of config.extensions) {
+            if (!extensionsList.some((e) => e.packageName === configEntry.name)) {
+                extensionsList.push({
+                    name: configEntry.name,
+                    version: configEntry.version || 'unknown',
+                    packageName: configEntry.name,
+                    enabled: false,
+                    hooks: [],
+                    middleware: [],
+                    commands: [],
+                });
+            }
+        }
+        state.extensionsList = extensionsList;
+        state.selectedExtensionIndex = 0;
+        ui.statusBar.setContent(` ${extensionsList.length} extension${extensionsList.length !== 1 ? 's' : ''}`);
+    }
+    catch (error) {
+        state.extensionsList = [];
+        state.selectedExtensionIndex = 0;
+        ui.statusBar.setContent(` {red-fg}Failed to load extensions: ${error}{/red-fg}`);
+    }
+    renderExtensionsList(ui, state);
+    renderExtensionDetails(ui, state);
+    ui.listContent.focus();
+    ui.screen.render();
+}
+/**
+ * Update extension selection and refresh display
+ */
+export function selectExtension(state, ui) {
+    renderExtensionsList(ui, state);
+    renderExtensionDetails(ui, state);
+    ui.screen.render();
+}
+/**
+ * Toggle the selected extension's enabled state
+ */
+export async function toggleExtension(state, ui) {
+    const ext = state.extensionsList[state.selectedExtensionIndex];
+    if (!ext)
+        return;
+    const newEnabled = !ext.enabled;
+    ui.statusBar.setContent(` ${newEnabled ? 'Enabling' : 'Disabling'} ${ext.name}...`);
+    ui.screen.render();
+    try {
+        await addExtensionToConfig(ext.packageName, ext.version, newEnabled);
+        ext.enabled = newEnabled;
+        ui.statusBar.setContent(` ${newEnabled ? 'Enabled' : 'Disabled'} ${ext.name} (restart to apply)`);
+        renderExtensionsList(ui, state);
+        renderExtensionDetails(ui, state);
+        ui.screen.render();
+    }
+    catch (error) {
+        ui.statusBar.setContent(` {red-fg}Failed: ${error}{/red-fg}`);
+        ui.screen.render();
+    }
+}

package/dist/tui/browse-handlers-pending.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Pending proposal handlers for the Lore Document Browser TUI
+ *
+ * Handles viewing, approving, and rejecting extension proposals.
+ */
+import type { BrowserState, UIComponents } from './browse-types.js';
+/**
+ * Show the pending proposals view
+ */
+export declare function showPendingView(state: BrowserState, ui: UIComponents, dbPath: string, dataDir: string): Promise<void>;
+/**
+ * Refresh the pending proposals list
+ */
+export declare function refreshPendingView(state: BrowserState, ui: UIComponents): Promise<void>;
+/**
+ * Approve the currently selected proposal
+ */
+export declare function approveSelectedProposal(state: BrowserState, ui: UIComponents, dbPath: string, dataDir: string): void;
+/**
+ * Reject the currently selected proposal
+ */
+export declare function rejectSelectedProposal(state: BrowserState, ui: UIComponents): void;

package/dist/tui/browse-handlers-pending.js

@@ -0,0 +1,100 @@
+/**
+ * Pending proposal handlers for the Lore Document Browser TUI
+ *
+ * Handles viewing, approving, and rejecting extension proposals.
+ */
+import { renderPendingList, renderPendingPreview, updateStatus } from './browse-render.js';
+import { listPendingProposals, approveProposal, rejectProposal } from '../extensions/proposals.js';
+/**
+ * Show the pending proposals view
+ */
+export async function showPendingView(state, ui, dbPath, dataDir) {
+    ui.statusBar.setContent(' Loading pending proposals...');
+    ui.screen.render();
+    state.pendingList = await listPendingProposals();
+    state.selectedPendingIndex = 0;
+    state.mode = 'pending';
+    state.pendingConfirmAction = null;
+    ui.listTitle.setContent(' Pending');
+    ui.previewTitle.setContent(' Proposal');
+    ui.footer.setContent(' ↑↓ Navigate  │  a Approve  │  x Reject  │  Esc Back');
+    renderPendingList(ui, state);
+    renderPendingPreview(ui, state);
+    updateStatus(ui, state);
+    ui.screen.render();
+}
+/**
+ * Refresh the pending proposals list
+ */
+export async function refreshPendingView(state, ui) {
+    state.pendingList = await listPendingProposals();
+    if (state.selectedPendingIndex >= state.pendingList.length) {
+        state.selectedPendingIndex = Math.max(0, state.pendingList.length - 1);
+    }
+    renderPendingList(ui, state);
+    renderPendingPreview(ui, state);
+    updateStatus(ui, state);
+    ui.screen.render();
+}
+/**
+ * Show confirmation dialog for pending action
+ */
+function confirmPendingAction(state, ui, prompt, onConfirm) {
+    state.pendingConfirmAction = prompt.includes('Reject') ? 'reject' : 'approve';
+    ui.statusBar.setContent(` ${prompt} (y/n)`);
+    ui.screen.render();
+    const handler = async (_ch, key) => {
+        if (!key?.name)
+            return;
+        if (key.name === 'y') {
+            ui.screen.removeListener('keypress', handler);
+            state.pendingConfirmAction = null;
+            await onConfirm();
+            return;
+        }
+        if (key.name === 'n' || key.name === 'escape') {
+            ui.screen.removeListener('keypress', handler);
+            state.pendingConfirmAction = null;
+            updateStatus(ui, state);
+            renderPendingPreview(ui, state);
+            ui.screen.render();
+        }
+    };
+    ui.screen.on('keypress', handler);
+}
+/**
+ * Approve the currently selected proposal
+ */
+export function approveSelectedProposal(state, ui, dbPath, dataDir) {
+    const proposal = state.pendingList[state.selectedPendingIndex];
+    if (!proposal || proposal.status !== 'pending')
+        return;
+    confirmPendingAction(state, ui, 'Approve proposal', async () => {
+        await approveProposal(proposal.id, dbPath, dataDir);
+        await refreshPendingView(state, ui);
+        ui.statusBar.setContent(` {green-fg}Approved ${proposal.id}{/green-fg}`);
+        ui.screen.render();
+        setTimeout(() => {
+            updateStatus(ui, state);
+            ui.screen.render();
+        }, 1200);
+    });
+}
+/**
+ * Reject the currently selected proposal
+ */
+export function rejectSelectedProposal(state, ui) {
+    const proposal = state.pendingList[state.selectedPendingIndex];
+    if (!proposal || proposal.status !== 'pending')
+        return;
+    confirmPendingAction(state, ui, 'Reject proposal', async () => {
+        await rejectProposal(proposal.id, 'Rejected in TUI');
+        await refreshPendingView(state, ui);
+        ui.statusBar.setContent(` {yellow-fg}Rejected ${proposal.id}{/yellow-fg}`);
+        ui.screen.render();
+        setTimeout(() => {
+            updateStatus(ui, state);
+            ui.screen.render();
+        }, 1200);
+    });
+}

package/dist/tui/browse-handlers-research.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Research handlers for the Lore Document Browser TUI
+ *
+ * Spawns the full agentic research mode for comprehensive,
+ * iterative research with citations.
+ *
+ * Supports slash commands and maintains research history.
+ *
+ * Slash commands:
+ *   /project <name> or /p <name> - Set project filter
+ *   /type <type> or /t <type>    - Set content type filter
+ *   /clear                       - Clear all filters
+ *   /new                         - Clear research history
+ *   /help or /?                  - Show available commands
+ */
+import type { BrowserState, UIComponents } from './browse-types.js';
+/**
+ * Enter research mode - show input for research task
+ */
+export declare function enterResearchMode(state: BrowserState, ui: UIComponents): void;
+/**
+ * Exit research mode - return to list
+ */
+export declare function exitResearchMode(state: BrowserState, ui: UIComponents): void;
+/**
+ * Prompt for next input after research completes
+ */
+export declare function promptForFollowUpResearch(state: BrowserState, ui: UIComponents): void;
+/**
+ * Execute the research task
+ */
+export declare function executeResearch(state: BrowserState, ui: UIComponents, dbPath: string, dataDir: string, query: string): Promise<void>;

package/dist/tui/browse-handlers-research.js

@@ -0,0 +1,363 @@
+/**
+ * Research handlers for the Lore Document Browser TUI
+ *
+ * Spawns the full agentic research mode for comprehensive,
+ * iterative research with citations.
+ *
+ * Supports slash commands and maintains research history.
+ *
+ * Slash commands:
+ *   /project <name> or /p <name> - Set project filter
+ *   /type <type> or /t <type>    - Set content type filter
+ *   /clear                       - Clear all filters
+ *   /new                         - Clear research history
+ *   /help or /?                  - Show available commands
+ */
+import { handleResearch } from '../mcp/handlers/research.js';
+import { showProjectPicker, showContentTypeFilter } from './browse-handlers.js';
+const CONTENT_TYPES = ['interview', 'meeting', 'conversation', 'document', 'note', 'analysis'];
+/**
+ * Build the filter display string
+ */
+function getFilterDisplay(state) {
+    const filters = [];
+    if (state.currentProject)
+        filters.push(`project: ${state.currentProject}`);
+    if (state.currentContentType)
+        filters.push(`type: ${state.currentContentType}`);
+    const filterInfo = filters.length > 0
+        ? `{yellow-fg}Scope: ${filters.join(', ')}{/yellow-fg}`
+        : '{blue-fg}No filters{/blue-fg}';
+    const footerNote = filters.length > 0
+        ? `{yellow-fg}${filters.join(', ')}{/yellow-fg}`
+        : '{blue-fg}all sources{/blue-fg}';
+    return { filters, filterInfo, footerNote };
+}
+/**
+ * Render the research pane with history
+ */
+function renderResearchPane(state, ui) {
+    const { filterInfo } = getFilterDisplay(state);
+    const lines = [];
+    // Show filter status at top
+    lines.push(`${filterInfo}  {blue-fg}│{/blue-fg}  {white-fg}/help{/white-fg} for commands  {blue-fg}│{/blue-fg}  {white-fg}/new{/white-fg} to start fresh`);
+    lines.push('');
+    // Show research history
+    if (state.researchHistory.length > 0) {
+        for (const item of state.researchHistory) {
+            lines.push(`{cyan-fg}Research:{/cyan-fg} ${item.query}`);
+            lines.push('');
+            // Escape blessed tags in summary
+            const escaped = item.summary
+                .replace(/\{/g, '\\{')
+                .replace(/\}/g, '\\}');
+            lines.push(escaped);
+            lines.push('');
+            lines.push('{blue-fg}───────────────────────────────────────{/blue-fg}');
+            lines.push('');
+        }
+    }
+    // Show current research if running
+    if (state.researchRunning) {
+        lines.push(`{cyan-fg}Research:{/cyan-fg} ${state.researchQuery}`);
+        lines.push('');
+        lines.push('{yellow-fg}Researching... (agent is exploring sources){/yellow-fg}');
+    }
+    else if (state.researchHistory.length === 0) {
+        lines.push('{blue-fg}Enter a research task to begin comprehensive analysis...{/blue-fg}');
+        lines.push('');
+        lines.push('{blue-fg}The research agent will iteratively explore sources,{/blue-fg}');
+        lines.push('{blue-fg}cross-reference findings, and synthesize results.{/blue-fg}');
+    }
+    ui.askPane.setContent(lines.join('\n'));
+}
+/**
+ * Update the footer for research mode
+ */
+function updateResearchFooter(ui, state, status) {
+    const { footerNote } = getFilterDisplay(state);
+    if (status) {
+        ui.footer.setContent(` ${status}  │  Scope: ${footerNote}`);
+    }
+    else if (state.researchRunning) {
+        ui.footer.setContent(` Researching...  │  Scope: ${footerNote}`);
+    }
+    else {
+        const historyNote = state.researchHistory.length > 0 ? `${state.researchHistory.length} tasks  │  ` : '';
+        ui.footer.setContent(` ${historyNote}Enter: Research  │  Esc: Back  │  Scope: ${footerNote}`);
+    }
+}
+/**
+ * Enter research mode - show input for research task
+ */
+export function enterResearchMode(state, ui) {
+    state.mode = 'research';
+    state.researchQuery = '';
+    state.researchRunning = false;
+    // Don't clear history - allow viewing previous research
+    // Hide list/preview panes
+    ui.listPane.hide();
+    ui.previewPane.hide();
+    // Reuse ask UI components
+    ui.askInput.show();
+    ui.askInput.setValue('');
+    ui.askPane.show();
+    ui.askPane.setLabel(' Research Agent ');
+    renderResearchPane(state, ui);
+    updateResearchFooter(ui, state);
+    ui.askInput.focus();
+    ui.askInput.readInput();
+    ui.screen.render();
+}
+/**
+ * Exit research mode - return to list
+ */
+export function exitResearchMode(state, ui) {
+    state.mode = 'list';
+    state.researchQuery = '';
+    state.researchRunning = false;
+    state.researchResponse = '';
+    // Keep researchHistory for when they come back
+    // Clear research-mode filters so they don't affect list operations
+    state.currentProject = undefined;
+    state.currentContentType = undefined;
+    ui.askInput.hide();
+    ui.askInput.setValue('');
+    ui.askPane.hide();
+    ui.askPane.setLabel(' Response ');
+    ui.listPane.show();
+    ui.previewPane.show();
+    ui.footer.setContent(' j/k Nav │ / Search │ a Ask │ R Research │ p Proj │ c Type │ m Move │ i Edit │ Esc Quit │ ? Help');
+    ui.listContent.focus();
+    ui.screen.render();
+}
+/**
+ * Show help for slash commands
+ */
+function showCommandHelp(ui, state) {
+    const helpText = `{bold}Slash Commands:{/bold}
+
+  /p or /project   Show project picker
+  /p <name>        Set project filter directly
+  /t or /type      Show content type picker
+  /t <type>        Set type filter directly
+                   (interview, meeting, conversation,
+                    document, note, analysis)
+  /clear           Clear all filters
+  /new             Clear research history
+  /help or /?      Show this help
+
+{bold}Current filters:{/bold}
+  Project: ${state.currentProject || '(none)'}
+  Type: ${state.currentContentType || '(none)'}
+
+{blue-fg}Press Enter to continue...{/blue-fg}`;
+    ui.askPane.setContent(helpText);
+    ui.screen.render();
+}
+/**
+ * Handle slash commands
+ * Returns true if input was a command (handled), false if it's a research task
+ */
+async function handleSlashCommand(input, state, ui, dbPath) {
+    const trimmed = input.trim();
+    if (!trimmed.startsWith('/'))
+        return false;
+    const parts = trimmed.slice(1).split(/\s+/);
+    const cmd = parts[0].toLowerCase();
+    const arg = parts.slice(1).join(' ');
+    switch (cmd) {
+        case 'help':
+        case '?':
+            showCommandHelp(ui, state);
+            return true;
+        case 'new':
+            state.researchHistory = [];
+            state.researchResponse = '';
+            renderResearchPane(state, ui);
+            updateResearchFooter(ui, state, 'Research history cleared');
+            ui.screen.render();
+            return true;
+        case 'clear':
+            state.currentProject = undefined;
+            state.currentContentType = undefined;
+            renderResearchPane(state, ui);
+            updateResearchFooter(ui, state, 'Filters cleared');
+            ui.screen.render();
+            return true;
+        case 'p':
+        case 'project': {
+            if (!arg) {
+                // Show interactive project picker
+                state.pickerReturnMode = 'research';
+                ui.askInput.hide();
+                ui.askPane.hide();
+                showProjectPicker(state, ui, dbPath);
+                return true;
+            }
+            state.currentProject = arg;
+            renderResearchPane(state, ui);
+            updateResearchFooter(ui, state, `Project set to: ${arg}`);
+            ui.screen.render();
+            return true;
+        }
+        case 't':
+        case 'type': {
+            if (!arg) {
+                // Show interactive content type picker
+                state.pickerReturnMode = 'research';
+                ui.askInput.hide();
+                ui.askPane.hide();
+                showContentTypeFilter(state, ui);
+                return true;
+            }
+            if (!CONTENT_TYPES.includes(arg)) {
+                ui.askPane.setContent(`{red-fg}Unknown type: ${arg}{/red-fg}\n\nAvailable: ${CONTENT_TYPES.join(', ')}`);
+                ui.screen.render();
+                return true;
+            }
+            state.currentContentType = arg;
+            renderResearchPane(state, ui);
+            updateResearchFooter(ui, state, `Type set to: ${arg}`);
+            ui.screen.render();
+            return true;
+        }
+        default:
+            ui.askPane.setContent(`{red-fg}Unknown command: /${cmd}{/red-fg}\n\nType /help for available commands.`);
+            ui.screen.render();
+            return true;
+    }
+}
+/**
+ * Prompt for next input after research completes
+ */
+export function promptForFollowUpResearch(state, ui) {
+    ui.askInput.show();
+    ui.askInput.setValue('');
+    ui.askInput.focus();
+    ui.askInput.readInput();
+    updateResearchFooter(ui, state);
+    ui.screen.render();
+}
+/**
+ * Format research package for display
+ */
+function formatResearchResult(result) {
+    const lines = [];
+    // Summary
+    lines.push('{bold}Summary{/bold}');
+    lines.push('');
+    lines.push(result.summary);
+    lines.push('');
+    // Key findings
+    if (result.key_findings?.length) {
+        lines.push('{bold}Key Findings{/bold}');
+        for (const finding of result.key_findings) {
+            lines.push(`• ${finding}`);
+        }
+        lines.push('');
+    }
+    // Conflicts resolved
+    if (result.conflicts_resolved?.length) {
+        lines.push('{bold}Conflicts Resolved{/bold}');
+        for (const conflict of result.conflicts_resolved) {
+            lines.push(`• ${conflict}`);
+        }
+        lines.push('');
+    }
+    // Supporting quotes (limit to 5 for brevity in history)
+    if (result.supporting_quotes?.length) {
+        lines.push('{bold}Key Quotes{/bold}');
+        for (const quote of result.supporting_quotes.slice(0, 5)) {
+            const speaker = quote.speaker_name || quote.speaker || 'Unknown';
+            lines.push(`"${quote.text}"`);
+            lines.push(`  — ${speaker}${quote.citation?.context ? ` (${quote.citation.context})` : ''}`);
+        }
+        if (result.supporting_quotes.length > 5) {
+            lines.push(`  ... and ${result.supporting_quotes.length - 5} more quotes`);
+        }
+        lines.push('');
+    }
+    // Sources consulted
+    if (result.sources_consulted?.length) {
+        lines.push('{bold}Sources ({/bold}' + result.sources_consulted.length + '{bold}){/bold}');
+        for (const source of result.sources_consulted.slice(0, 5)) {
+            lines.push(`• ${source.title}`);
+        }
+        if (result.sources_consulted.length > 5) {
+            lines.push(`  ... and ${result.sources_consulted.length - 5} more`);
+        }
+        lines.push('');
+    }
+    // Gaps identified
+    if (result.gaps_identified?.length) {
+        lines.push('{bold}Gaps Identified{/bold}');
+        for (const gap of result.gaps_identified) {
+            lines.push(`• ${gap}`);
+        }
+        lines.push('');
+    }
+    // Suggested queries
+    if (result.suggested_queries?.length) {
+        lines.push('{bold}Suggested Follow-ups{/bold}');
+        for (const query of result.suggested_queries) {
+            lines.push(`• ${query}`);
+        }
+    }
+    return lines.join('\n');
+}
+/**
+ * Execute the research task
+ */
+export async function executeResearch(state, ui, dbPath, dataDir, query) {
+    const trimmed = query.trim();
+    if (!trimmed) {
+        renderResearchPane(state, ui);
+        promptForFollowUpResearch(state, ui);
+        return;
+    }
+    // Check for slash commands
+    if (await handleSlashCommand(trimmed, state, ui, dbPath)) {
+        promptForFollowUpResearch(state, ui);
+        return;
+    }
+    if (!process.env.ANTHROPIC_API_KEY) {
+        ui.askPane.setContent('{red-fg}Error: ANTHROPIC_API_KEY not set{/red-fg}');
+        ui.screen.render();
+        return;
+    }
+    state.researchQuery = trimmed;
+    state.researchRunning = true;
+    ui.askInput.hide();
+    renderResearchPane(state, ui);
+    updateResearchFooter(ui, state);
+    ui.screen.render();
+    try {
+        // Run the full research agent
+        const result = await handleResearch(dbPath, dataDir, {
+            task: trimmed,
+            project: state.currentProject || undefined,
+            content_type: state.currentContentType || undefined,
+            include_sources: true,
+        }, { hookContext: { mode: 'cli' } });
+        state.researchRunning = false;
+        // Format and add to history
+        const formatted = formatResearchResult(result);
+        state.researchHistory.push({
+            query: trimmed,
+            summary: formatted,
+        });
+        renderResearchPane(state, ui);
+        promptForFollowUpResearch(state, ui);
+    }
+    catch (error) {
+        state.researchRunning = false;
+        const errorMsg = error instanceof Error ? error.message : String(error);
+        state.researchHistory.push({
+            query: trimmed,
+            summary: `Error: ${errorMsg}`,
+        });
+        renderResearchPane(state, ui);
+        promptForFollowUpResearch(state, ui);
+    }
+}

package/dist/tui/browse-handlers-tools.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Tool handlers for the Lore Document Browser TUI
+ *
+ * Handles tool listing, form display, and execution.
+ */
+import type { BrowserState, UIComponents, ToolFormField } from './browse-types.js';
+/**
+ * Parse tool input schema into form fields
+ */
+export declare function parseInputSchema(inputSchema: Record<string, unknown>): ToolFormField[];
+/**
+ * Show the tools list view
+ */
+export declare function showTools(state: BrowserState, ui: UIComponents): Promise<void>;
+/**
+ * Update tool selection and refresh display
+ */
+export declare function selectTool(state: BrowserState, ui: UIComponents): void;
+/**
+ * Show the tool input form
+ */
+export declare function showToolForm(state: BrowserState, ui: UIComponents): void;
+/**
+ * Hide the tool input form
+ */
+export declare function hideToolForm(state: BrowserState, ui: UIComponents): void;
+/**
+ * Move to next form field
+ */
+export declare function formFieldNext(state: BrowserState, ui: UIComponents): void;
+/**
+ * Move to previous form field
+ */
+export declare function formFieldPrev(state: BrowserState, ui: UIComponents): void;
+/**
+ * Update current form field value
+ */
+export declare function formFieldUpdate(state: BrowserState, ui: UIComponents, value: ToolFormField['value']): void;
+/**
+ * Execute the selected tool with current form values
+ */
+export declare function callTool(state: BrowserState, ui: UIComponents, dbPath: string, dataDir: string): Promise<boolean>;