@getlore/cli 0.2.0

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

@@ -0,0 +1,289 @@
+/**
+ * Tool handlers for the Lore Document Browser TUI
+ *
+ * Handles tool listing, form display, and execution.
+ */
+import { renderToolsList, renderToolForm, renderToolResult } from './browse-render-tools.js';
+import { getExtensionRegistry } from '../extensions/registry.js';
+/**
+ * Parse tool input schema into form fields
+ */
+export function parseInputSchema(inputSchema) {
+    if (!inputSchema || typeof inputSchema !== 'object')
+        return [];
+    const schema = inputSchema;
+    const properties = schema.properties && typeof schema.properties === 'object'
+        ? schema.properties
+        : {};
+    const required = Array.isArray(schema.required) ? schema.required : [];
+    const fields = [];
+    for (const [name, prop] of Object.entries(properties)) {
+        const propType = typeof prop === 'object' && prop ? prop.type : undefined;
+        let type = 'string';
+        if (propType === 'number' || propType === 'integer') {
+            type = 'number';
+        }
+        else if (propType === 'boolean') {
+            type = 'boolean';
+        }
+        else if (propType === 'string') {
+            type = 'string';
+        }
+        const description = typeof prop?.description === 'string' ? prop.description : '';
+        const defaultValue = prop?.default;
+        let value;
+        if (defaultValue !== undefined) {
+            if (type === 'boolean') {
+                value = Boolean(defaultValue);
+            }
+            else if (type === 'number') {
+                const numeric = typeof defaultValue === 'number' ? defaultValue : Number(defaultValue);
+                value = Number.isNaN(numeric) ? '' : numeric;
+            }
+            else {
+                value = String(defaultValue);
+            }
+        }
+        else if (type === 'boolean') {
+            value = false;
+        }
+        else {
+            value = '';
+        }
+        fields.push({
+            name,
+            type,
+            description,
+            default: defaultValue,
+            required: required.includes(name),
+            value,
+        });
+    }
+    return fields;
+}
+function setToolFormFields(state, tool) {
+    if (!tool || !tool.inputSchema) {
+        state.toolFormFields = [];
+        state.toolFormIndex = 0;
+        return;
+    }
+    state.toolFormFields = parseInputSchema(tool.inputSchema);
+    state.toolFormIndex = 0;
+}
+/**
+ * Show the tools list view
+ */
+export async function showTools(state, ui) {
+    state.mode = 'tools';
+    state.toolResult = null;
+    ui.toolForm.hide();
+    ui.fullViewPane.hide();
+    ui.listPane.show();
+    ui.previewPane.show();
+    ui.listTitle.setContent(' Tools');
+    ui.previewTitle.setContent(' Tool Details');
+    ui.footer.setContent(' j/k: navigate  Enter: run  Esc: back  q: quit');
+    ui.statusBar.setContent(' Loading tools...');
+    ui.screen.render();
+    try {
+        const registry = await getExtensionRegistry();
+        state.toolsList = registry.getToolDefinitions();
+        state.selectedToolIndex = 0;
+        ui.statusBar.setContent(` ${state.toolsList.length} tool${state.toolsList.length !== 1 ? 's' : ''}`);
+        setToolFormFields(state, state.toolsList[state.selectedToolIndex]);
+    }
+    catch (error) {
+        state.toolsList = [];
+        state.selectedToolIndex = 0;
+        state.toolFormFields = [];
+        state.toolFormIndex = 0;
+        ui.statusBar.setContent(` {red-fg}Failed to load tools: ${error}{/red-fg}`);
+    }
+    renderToolsList(ui, state);
+    renderToolResult(ui, state);
+    ui.listContent.focus();
+    ui.screen.render();
+}
+/**
+ * Update tool selection and refresh display
+ */
+export function selectTool(state, ui) {
+    const tool = state.toolsList[state.selectedToolIndex];
+    setToolFormFields(state, tool);
+    renderToolsList(ui, state);
+    renderToolResult(ui, state);
+    if (!ui.toolForm.hidden) {
+        renderToolForm(ui, state);
+    }
+    ui.screen.render();
+}
+/**
+ * Show the tool input form
+ */
+export function showToolForm(state, ui) {
+    const tool = state.toolsList[state.selectedToolIndex];
+    if (!tool)
+        return;
+    setToolFormFields(state, tool);
+    ui.toolForm.setLabel(` ${tool.name} `);
+    ui.toolForm.show();
+    renderToolForm(ui, state);
+    ui.footer.setContent(' Tab: next field  Enter: run  Esc: back');
+    ui.screen.render();
+}
+/**
+ * Hide the tool input form
+ */
+export function hideToolForm(state, ui) {
+    ui.toolForm.hide();
+    ui.footer.setContent(' j/k: navigate  Enter: run  Esc: back  q: quit');
+    ui.screen.render();
+}
+/**
+ * Move to next form field
+ */
+export function formFieldNext(state, ui) {
+    if (state.toolFormFields.length === 0)
+        return;
+    state.toolFormIndex = (state.toolFormIndex + 1) % state.toolFormFields.length;
+    renderToolForm(ui, state);
+    ui.screen.render();
+}
+/**
+ * Move to previous form field
+ */
+export function formFieldPrev(state, ui) {
+    if (state.toolFormFields.length === 0)
+        return;
+    state.toolFormIndex = (state.toolFormIndex - 1 + state.toolFormFields.length) % state.toolFormFields.length;
+    renderToolForm(ui, state);
+    ui.screen.render();
+}
+/**
+ * Update current form field value
+ */
+export function formFieldUpdate(state, ui, value) {
+    const field = state.toolFormFields[state.toolFormIndex];
+    if (!field)
+        return;
+    field.value = value;
+    renderToolForm(ui, state);
+    ui.screen.render();
+}
+/**
+ * Execute the selected tool with current form values
+ */
+export async function callTool(state, ui, dbPath, dataDir) {
+    const tool = state.toolsList[state.selectedToolIndex];
+    if (!tool)
+        return false;
+    const args = {};
+    const missing = [];
+    for (const field of state.toolFormFields) {
+        if (field.type === 'boolean') {
+            const value = Boolean(field.value);
+            if (value || field.required || field.default !== undefined) {
+                args[field.name] = value;
+            }
+            continue;
+        }
+        if (field.type === 'number') {
+            const raw = field.value === undefined || field.value === null ? '' : String(field.value);
+            if (!raw.trim()) {
+                if (field.required)
+                    missing.push(field.name);
+                continue;
+            }
+            const numeric = Number(raw);
+            if (Number.isNaN(numeric)) {
+                state.toolResult = {
+                    toolName: tool.name,
+                    ok: false,
+                    result: `Invalid number for "${field.name}"`,
+                };
+                renderToolResult(ui, state);
+                ui.screen.render();
+                return false;
+            }
+            args[field.name] = numeric;
+            continue;
+        }
+        const text = field.value === undefined || field.value === null ? '' : String(field.value);
+        if (!text.trim()) {
+            if (field.required)
+                missing.push(field.name);
+            continue;
+        }
+        args[field.name] = text;
+    }
+    if (missing.length > 0) {
+        state.toolResult = {
+            toolName: tool.name,
+            ok: false,
+            result: `Missing required field(s): ${missing.join(', ')}`,
+        };
+        renderToolResult(ui, state);
+        ui.screen.render();
+        return false;
+    }
+    state.toolRunning = true;
+    state.toolStartTime = Date.now();
+    // Hide form and show running state clearly
+    ui.toolForm.hide();
+    ui.statusBar.setContent(` ⏳ Running ${tool.name}... (this may take a moment)`);
+    state.toolResult = {
+        toolName: tool.name,
+        ok: true,
+        result: { status: 'running', message: 'Please wait...' },
+    };
+    renderToolResult(ui, state);
+    ui.screen.render();
+    try {
+        const registry = await getExtensionRegistry();
+        const result = await registry.handleToolCall(tool.name, args, {
+            mode: 'cli',
+            dataDir,
+            dbPath,
+            // Silence extension logs in TUI mode
+            logger: () => { },
+        });
+        state.toolRunning = false;
+        state.toolStartTime = null;
+        if (!result.handled) {
+            state.toolResult = {
+                toolName: tool.name,
+                ok: false,
+                result: 'Tool not found',
+            };
+            ui.statusBar.setContent(` {red-fg}✗ ${tool.name}: Tool not found{/red-fg}`);
+        }
+        else {
+            state.toolResult = {
+                toolName: tool.name,
+                ok: true,
+                result: result.result,
+            };
+            // Check if result contains a proposal - notify user
+            const resultObj = result.result;
+            if (resultObj && typeof resultObj === 'object' && 'proposal_id' in resultObj) {
+                ui.statusBar.setContent(` {green-fg}✓ ${tool.name} complete{/green-fg} — {yellow-fg}Press 'r' to review pending proposal{/yellow-fg}`);
+            }
+            else {
+                ui.statusBar.setContent(` {green-fg}✓ ${tool.name} complete{/green-fg}`);
+            }
+        }
+    }
+    catch (error) {
+        state.toolRunning = false;
+        state.toolStartTime = null;
+        state.toolResult = {
+            toolName: tool.name,
+            ok: false,
+            result: error instanceof Error ? error.message : String(error),
+        };
+        ui.statusBar.setContent(` {red-fg}✗ ${tool.name} failed{/red-fg}`);
+    }
+    renderToolResult(ui, state);
+    ui.screen.render();
+    return true;
+}

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

@@ -0,0 +1,239 @@
+/**
+ * Event handlers and operations for the Lore Document Browser TUI
+ *
+ * Contains navigation, search, editor integration, and mode switching.
+ */
+import type { BrowserState, UIComponents } from './browse-types.js';
+import type { SearchMode, SourceType } from '../core/types.js';
+/**
+ * Helper to re-render ask/research pane when returning from pickers
+ * Exported so browse.ts can use it for autocomplete direct selection
+ */
+export declare function renderReturnToAskOrResearch(state: BrowserState, ui: UIComponents, mode: 'ask' | 'research'): void;
+/**
+ * Load full content for the selected document
+ */
+export declare function loadFullContent(state: BrowserState, ui: UIComponents, dbPath: string, sourcesDir: string): Promise<void>;
+/**
+ * Enter full view mode
+ */
+export declare function enterFullView(state: BrowserState, ui: UIComponents, dbPath: string, sourcesDir: string): Promise<void>;
+/**
+ * Exit full view mode
+ */
+export declare function exitFullView(state: BrowserState, ui: UIComponents): void;
+/**
+ * Enter semantic/hybrid search mode
+ */
+export declare function enterSearch(state: BrowserState, ui: UIComponents): void;
+/**
+ * Enter regex search mode
+ */
+export declare function enterRegexSearch(state: BrowserState, ui: UIComponents): void;
+/**
+ * Exit search mode
+ */
+export declare function exitSearch(state: BrowserState, ui: UIComponents): void;
+/**
+ * Enter document search mode (within full view)
+ */
+export declare function enterDocSearch(state: BrowserState, ui: UIComponents): void;
+/**
+ * Exit document search mode
+ */
+export declare function exitDocSearch(state: BrowserState, ui: UIComponents, clearPattern?: boolean): void;
+/**
+ * Apply document search pattern
+ */
+export declare function applyDocSearch(state: BrowserState, ui: UIComponents, pattern: string): void;
+/**
+ * Scroll to a specific match
+ */
+export declare function scrollToMatch(state: BrowserState, ui: UIComponents, matchIdx: number): void;
+/**
+ * Go to next match
+ */
+export declare function nextMatch(state: BrowserState, ui: UIComponents): void;
+/**
+ * Go to previous match
+ */
+export declare function prevMatch(state: BrowserState, ui: UIComponents): void;
+/**
+ * Apply search filter
+ */
+export declare function applyFilter(state: BrowserState, ui: UIComponents, query: string, filterMode: SearchMode, dbPath: string, dataDir: string, project?: string, sourceType?: SourceType): Promise<void>;
+/**
+ * Show help overlay
+ */
+export declare function showHelp(state: BrowserState, ui: UIComponents): void;
+/**
+ * Hide help overlay
+ */
+export declare function hideHelp(state: BrowserState, ui: UIComponents): void;
+export declare function openInEditor(state: BrowserState, ui: UIComponents, sourcesDir: string): Promise<void>;
+export declare function moveDown(state: BrowserState, ui: UIComponents): void;
+export declare function moveUp(state: BrowserState, ui: UIComponents): void;
+export declare function pageDown(state: BrowserState, ui: UIComponents): void;
+export declare function pageUp(state: BrowserState, ui: UIComponents): void;
+export declare function jumpToEnd(state: BrowserState, ui: UIComponents): void;
+export declare function jumpToStart(state: BrowserState, ui: UIComponents): void;
+/**
+ * Trigger a manual sync
+ */
+export declare function triggerSync(state: BrowserState, ui: UIComponents, dbPath: string, dataDir: string, project?: string, sourceType?: SourceType): Promise<void>;
+/**
+ * Load projects and show the project picker
+ */
+export declare function showProjectPicker(state: BrowserState, ui: UIComponents, dbPath: string): Promise<void>;
+/**
+ * Render the project picker content
+ */
+export declare function renderProjectPicker(state: BrowserState, ui: UIComponents): void;
+/**
+ * Navigate project picker down
+ */
+export declare function projectPickerDown(state: BrowserState, ui: UIComponents): void;
+/**
+ * Navigate project picker up
+ */
+export declare function projectPickerUp(state: BrowserState, ui: UIComponents): void;
+/**
+ * Select current project and filter documents
+ */
+export declare function selectProject(state: BrowserState, ui: UIComponents, dbPath: string, dataDir: string, sourceType?: SourceType): Promise<void>;
+/**
+ * Cancel project picker
+ */
+export declare function cancelProjectPicker(state: BrowserState, ui: UIComponents): void;
+/**
+ * Clear project filter (show all)
+ */
+export declare function clearProjectFilter(state: BrowserState, ui: UIComponents, dbPath: string, dataDir: string, sourceType?: SourceType): Promise<void>;
+/**
+ * Show delete confirmation dialog (for document or project)
+ */
+export declare function showDeleteConfirm(state: BrowserState, ui: UIComponents): void;
+/**
+ * Cancel delete operation
+ */
+export declare function cancelDelete(state: BrowserState, ui: UIComponents): void;
+/**
+ * Confirm and execute delete operation (document or project)
+ */
+export declare function confirmDelete(state: BrowserState, ui: UIComponents, dbPath: string, dataDir: string, project?: string, sourceType?: import('../core/types.js').SourceType): Promise<void>;
+/**
+ * Copy current view content to clipboard
+ */
+export declare function copyCurrentContent(state: BrowserState, ui: UIComponents): Promise<void>;
+/**
+ * Show move picker to relocate a document to a different project
+ */
+export declare function showMovePicker(state: BrowserState, ui: UIComponents, dbPath: string): Promise<void>;
+/**
+ * Render the move picker UI
+ */
+export declare function renderMovePicker(state: BrowserState, ui: UIComponents): void;
+/**
+ * Navigate down in move picker
+ */
+export declare function movePickerDown(state: BrowserState, ui: UIComponents): void;
+/**
+ * Navigate up in move picker
+ */
+export declare function movePickerUp(state: BrowserState, ui: UIComponents): void;
+/**
+ * Confirm move to selected project
+ */
+export declare function confirmMove(state: BrowserState, ui: UIComponents, dbPath: string, dataDir: string, sourceType?: SourceType): Promise<void>;
+/**
+ * Cancel move picker
+ */
+export declare function cancelMovePicker(state: BrowserState, ui: UIComponents): void;
+/**
+ * Enter edit info mode for the selected document
+ */
+export declare function enterEditInfo(state: BrowserState, ui: UIComponents): void;
+/**
+ * Save edit info changes
+ */
+export declare function saveEditInfo(state: BrowserState, ui: UIComponents, dbPath: string, sourceType?: SourceType): Promise<void>;
+/**
+ * Exit edit info mode without saving
+ */
+export declare function exitEditInfo(state: BrowserState, ui: UIComponents): void;
+/**
+ * Show type picker to change document content type
+ */
+export declare function showTypePicker(state: BrowserState, ui: UIComponents): void;
+/**
+ * Render the type picker UI
+ */
+export declare function renderTypePicker(state: BrowserState, ui: UIComponents): void;
+/**
+ * Navigate down in type picker
+ */
+export declare function typePickerDown(state: BrowserState, ui: UIComponents): void;
+/**
+ * Navigate up in type picker
+ */
+export declare function typePickerUp(state: BrowserState, ui: UIComponents): void;
+/**
+ * Confirm type selection
+ */
+export declare function confirmTypeChange(state: BrowserState, ui: UIComponents, dbPath: string, sourceType?: SourceType): Promise<void>;
+/**
+ * Cancel type picker
+ */
+export declare function cancelTypePicker(state: BrowserState, ui: UIComponents): void;
+/**
+ * Show content type filter picker
+ */
+export declare function showContentTypeFilter(state: BrowserState, ui: UIComponents): void;
+/**
+ * Render the content type filter UI
+ */
+export declare function renderContentTypeFilter(state: BrowserState, ui: UIComponents): void;
+/**
+ * Navigate down in content type filter
+ */
+export declare function contentTypeFilterDown(state: BrowserState, ui: UIComponents): void;
+/**
+ * Navigate up in content type filter
+ */
+export declare function contentTypeFilterUp(state: BrowserState, ui: UIComponents): void;
+/**
+ * Apply content type filter
+ */
+export declare function applyContentTypeFilter(state: BrowserState, ui: UIComponents, dbPath: string, dataDir: string, sourceType?: SourceType): Promise<void>;
+/**
+ * Cancel content type filter picker
+ */
+export declare function cancelContentTypeFilter(state: BrowserState, ui: UIComponents): void;
+/**
+ * Clear content type filter
+ */
+export declare function clearContentTypeFilter(state: BrowserState, ui: UIComponents, dbPath: string, dataDir: string, sourceType?: SourceType): Promise<void>;
+/**
+ * Toggle expand/collapse for the currently selected project header
+ */
+export declare function toggleProjectExpand(state: BrowserState, ui: UIComponents): boolean;
+/**
+ * Expand the currently selected project (or the project containing the selected doc)
+ */
+export declare function expandCurrentProject(state: BrowserState, ui: UIComponents): void;
+/**
+ * Collapse the currently selected project (or the project containing the selected doc)
+ */
+export declare function collapseCurrentProject(state: BrowserState, ui: UIComponents): void;
+/**
+ * Toggle grouped view mode
+ */
+export declare function toggleGroupedView(state: BrowserState, ui: UIComponents): void;
+/**
+ * Check if selection is on a document (for Enter key handling)
+ */
+export declare function isDocumentSelected(state: BrowserState): boolean;
+/**
+ * Get the selected source for full view (handles both modes)
+ */
+export declare function getSelectedSourceForFullView(state: BrowserState): import('./browse-types.js').SourceItem | null;