@getlore/cli 0.2.0

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

@@ -0,0 +1,372 @@
+/**
+ * Ask handlers for the Lore Document Browser TUI
+ *
+ * Handles AI-powered queries with streaming responses.
+ * Supports slash commands and multi-turn conversations.
+ *
+ * Slash commands:
+ *   /project <name> or /p <name> - Set project filter
+ *   /type <type> or /t <type>    - Set content type filter
+ *   /clear                       - Clear all filters
+ *   /new                         - Start new conversation
+ *   /help or /?                  - Show available commands
+ */
+import Anthropic from '@anthropic-ai/sdk';
+import { searchSources } from '../core/vector-store.js';
+import { generateEmbedding } from '../core/embedder.js';
+import { showProjectPicker, showContentTypeFilter } from './browse-handlers.js';
+const SYSTEM_PROMPT = `You are a research assistant with access to a knowledge base.
+Your job is to answer questions based on the provided sources.
+
+When answering:
+- Cite specific sources when making claims
+- Be concise but thorough
+- If the sources don't contain enough information, say so
+- Consider previous conversation context when answering follow-up questions
+
+Source format: Each source has an ID, title, and content summary.`;
+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 conversation history and prompt
+ */
+function renderAskPane(state, ui, showInput = true) {
+    const { filterInfo } = getFilterDisplay(state);
+    const lines = [];
+    // Show filter status at top (using brighter colors for dark terminals)
+    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 conversation history
+    if (state.askHistory.length > 0) {
+        for (const msg of state.askHistory) {
+            if (msg.role === 'user') {
+                lines.push(`{cyan-fg}You:{/cyan-fg} ${msg.content}`);
+            }
+            else {
+                // Escape blessed tags in assistant response
+                const escaped = msg.content
+                    .replace(/\{/g, '\\{')
+                    .replace(/\}/g, '\\}');
+                lines.push(`{green-fg}Assistant:{/green-fg}`);
+                lines.push(escaped);
+            }
+            lines.push('');
+        }
+    }
+    // Show current streaming response if any
+    if (state.askStreaming && state.askResponse) {
+        lines.push(`{cyan-fg}You:{/cyan-fg} ${state.askQuery}`);
+        lines.push(`{green-fg}Assistant:{/green-fg}`);
+        const escaped = state.askResponse
+            .replace(/\{/g, '\\{')
+            .replace(/\}/g, '\\}');
+        lines.push(escaped);
+    }
+    else if (showInput && state.askHistory.length === 0) {
+        lines.push('{blue-fg}Ask a question about your knowledge base...{/blue-fg}');
+    }
+    ui.askPane.setContent(lines.join('\n'));
+}
+/**
+ * Update the footer for ask mode
+ */
+function updateAskFooter(ui, state, status) {
+    const { footerNote } = getFilterDisplay(state);
+    if (status) {
+        ui.footer.setContent(` ${status}  │  Scope: ${footerNote}`);
+    }
+    else if (state.askStreaming) {
+        ui.footer.setContent(` Generating...  │  Scope: ${footerNote}`);
+    }
+    else {
+        const historyNote = state.askHistory.length > 0 ? `${state.askHistory.length / 2} Q&A  │  ` : '';
+        ui.footer.setContent(` ${historyNote}Enter: Send  │  Esc: Back  │  Scope: ${footerNote}`);
+    }
+}
+/**
+ * Enter ask mode - show input for query
+ */
+export function enterAskMode(state, ui) {
+    state.mode = 'ask';
+    state.askQuery = '';
+    state.askResponse = '';
+    state.askStreaming = false;
+    // Don't clear history - allow continuing conversation
+    // Hide list/preview panes
+    ui.listPane.hide();
+    ui.previewPane.hide();
+    // Show ask UI
+    ui.askInput.show();
+    ui.askInput.setValue('');
+    ui.askPane.show();
+    ui.askPane.setLabel(' Ask Lore ');
+    renderAskPane(state, ui);
+    updateAskFooter(ui, state);
+    ui.askInput.focus();
+    ui.askInput.readInput();
+    ui.screen.render();
+}
+/**
+ * Exit ask mode - return to list
+ */
+export function exitAskMode(state, ui) {
+    state.mode = 'list';
+    state.askQuery = '';
+    state.askResponse = '';
+    state.askStreaming = false;
+    // Keep askHistory for when they come back
+    // Clear ask-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.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             Start new conversation (clear 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 question
+ */
+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.askHistory = [];
+            state.askResponse = '';
+            renderAskPane(state, ui);
+            updateAskFooter(ui, state, 'Conversation cleared');
+            ui.screen.render();
+            return true;
+        case 'clear':
+            state.currentProject = undefined;
+            state.currentContentType = undefined;
+            renderAskPane(state, ui);
+            updateAskFooter(ui, state, 'Filters cleared');
+            ui.screen.render();
+            return true;
+        case 'p':
+        case 'project': {
+            if (!arg) {
+                // Show interactive project picker
+                state.pickerReturnMode = 'ask';
+                ui.askInput.hide();
+                ui.askPane.hide();
+                showProjectPicker(state, ui, dbPath);
+                return true;
+            }
+            state.currentProject = arg;
+            renderAskPane(state, ui);
+            updateAskFooter(ui, state, `Project set to: ${arg}`);
+            ui.screen.render();
+            return true;
+        }
+        case 't':
+        case 'type': {
+            if (!arg) {
+                // Show interactive content type picker
+                state.pickerReturnMode = 'ask';
+                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;
+            renderAskPane(state, ui);
+            updateAskFooter(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 a response
+ */
+export function promptForFollowUp(state, ui) {
+    ui.askInput.show();
+    ui.askInput.setValue('');
+    ui.askInput.focus();
+    ui.askInput.readInput();
+    updateAskFooter(ui, state);
+    ui.screen.render();
+}
+/**
+ * Execute the ask query with streaming
+ */
+export async function executeAsk(state, ui, dbPath, query) {
+    const trimmed = query.trim();
+    if (!trimmed) {
+        renderAskPane(state, ui);
+        promptForFollowUp(state, ui);
+        return;
+    }
+    // Check for slash commands
+    if (await handleSlashCommand(trimmed, state, ui, dbPath)) {
+        promptForFollowUp(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.askQuery = trimmed;
+    state.askStreaming = true;
+    state.askResponse = '';
+    ui.askInput.hide();
+    renderAskPane(state, ui);
+    updateAskFooter(ui, state, 'Searching knowledge base...');
+    ui.screen.render();
+    try {
+        // Search for relevant sources
+        const embedding = await generateEmbedding(trimmed);
+        let sources = await searchSources(dbPath, embedding, {
+            limit: 20,
+            project: state.currentProject || undefined,
+            content_type: state.currentContentType || undefined,
+            queryText: trimmed,
+            mode: 'hybrid',
+        });
+        // Double-check content type filter
+        if (state.currentContentType) {
+            sources = sources.filter(s => s.content_type === state.currentContentType);
+        }
+        if (sources.length === 0) {
+            state.askStreaming = false;
+            // Add to history as a failed query
+            state.askHistory.push({ role: 'user', content: trimmed });
+            state.askHistory.push({ role: 'assistant', content: 'No relevant sources found for this query.' });
+            renderAskPane(state, ui);
+            promptForFollowUp(state, ui);
+            return;
+        }
+        // Build source context
+        const sourceContext = sources.map((s, i) => {
+            const parts = [`[Source ${i + 1}: ${s.title}]`];
+            if (s.summary)
+                parts.push(`Summary: ${s.summary}`);
+            if (s.themes?.length) {
+                parts.push(`Themes: ${s.themes.map(t => t.name).join(', ')}`);
+                for (const theme of s.themes.slice(0, 3)) {
+                    if (theme.summary) {
+                        parts.push(`  ${theme.name}: ${theme.summary}`);
+                    }
+                }
+            }
+            if (s.quotes?.length) {
+                parts.push('Key quotes:');
+                for (const q of s.quotes.slice(0, 8)) {
+                    const speaker = q.speaker_name || q.speaker || '';
+                    const speakerPrefix = speaker ? `[${speaker}] ` : '';
+                    parts.push(`  ${speakerPrefix}"${q.text}"`);
+                }
+            }
+            return parts.join('\n');
+        }).join('\n\n---\n\n');
+        updateAskFooter(ui, state, `Found ${sources.length} sources. Thinking...`);
+        ui.screen.render();
+        // Build messages array with history for multi-turn
+        const messages = [];
+        // Add conversation history (without source context for brevity)
+        for (const msg of state.askHistory) {
+            messages.push({ role: msg.role, content: msg.content });
+        }
+        // Add current question with source context
+        messages.push({
+            role: 'user',
+            content: `Question: ${trimmed}\n\n---\nSources:\n${sourceContext}`,
+        });
+        // Stream response
+        const anthropic = new Anthropic();
+        const stream = anthropic.messages.stream({
+            model: 'claude-sonnet-4-20250514',
+            max_tokens: 4096,
+            system: SYSTEM_PROMPT,
+            messages,
+        });
+        let response = '';
+        stream.on('text', (text) => {
+            response += text;
+            state.askResponse = response;
+            renderAskPane(state, ui);
+            ui.screen.render();
+        });
+        await stream.finalMessage();
+        state.askStreaming = false;
+        // Add to conversation history
+        state.askHistory.push({ role: 'user', content: trimmed });
+        state.askHistory.push({ role: 'assistant', content: response });
+        state.askResponse = '';
+        renderAskPane(state, ui);
+        promptForFollowUp(state, ui);
+    }
+    catch (error) {
+        state.askStreaming = false;
+        const errorMsg = error instanceof Error ? error.message : String(error);
+        state.askHistory.push({ role: 'user', content: trimmed });
+        state.askHistory.push({ role: 'assistant', content: `Error: ${errorMsg}` });
+        renderAskPane(state, ui);
+        promptForFollowUp(state, ui);
+    }
+}

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

@@ -0,0 +1,49 @@
+/**
+ * Autocomplete handlers for Ask/Research mode slash commands
+ *
+ * Provides typeahead suggestions as you type:
+ * - "/" shows available commands
+ * - "/p " or "/project " shows projects
+ * - "/t " or "/type " shows content types
+ */
+import type { BrowserState, UIComponents } from './browse-types.js';
+/**
+ * Update autocomplete based on current input
+ */
+export declare function updateAutocomplete(state: BrowserState, ui: UIComponents, dbPath: string, inputValue: string): Promise<void>;
+/**
+ * Render the autocomplete dropdown
+ */
+export declare function renderAutocomplete(state: BrowserState, ui: UIComponents): void;
+/**
+ * Hide the autocomplete dropdown
+ */
+export declare function hideAutocomplete(state: BrowserState, ui: UIComponents): void;
+/**
+ * Navigate autocomplete down
+ */
+export declare function autocompleteDown(state: BrowserState, ui: UIComponents): boolean;
+/**
+ * Navigate autocomplete up
+ */
+export declare function autocompleteUp(state: BrowserState, ui: UIComponents): boolean;
+/**
+ * Result from autocomplete selection
+ */
+export interface AutocompleteResult {
+    type: 'input' | 'project' | 'contentType';
+    value: string;
+}
+/**
+ * Select current autocomplete option
+ * Returns what was selected so caller can handle appropriately
+ */
+export declare function autocompleteSelect(state: BrowserState, ui: UIComponents): AutocompleteResult | null;
+/**
+ * Check if autocomplete handled a key event
+ * Returns true if the key was handled (should not propagate)
+ */
+export declare function handleAutocompleteKey(state: BrowserState, ui: UIComponents, key: string): {
+    handled: boolean;
+    result?: AutocompleteResult;
+};

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

@@ -0,0 +1,270 @@
+/**
+ * Autocomplete handlers for Ask/Research mode slash commands
+ *
+ * Provides typeahead suggestions as you type:
+ * - "/" shows available commands
+ * - "/p " or "/project " shows projects
+ * - "/t " or "/type " shows content types
+ */
+import { getAllSources } from '../core/vector-store.js';
+// Command definitions
+const SLASH_COMMANDS = [
+    { value: '/p', label: '/p', description: 'Select project filter' },
+    { value: '/project', label: '/project', description: 'Select project filter' },
+    { value: '/t', label: '/t', description: 'Select content type filter' },
+    { value: '/type', label: '/type', description: 'Select content type filter' },
+    { value: '/clear', label: '/clear', description: 'Clear all filters' },
+    { value: '/new', label: '/new', description: 'Start fresh conversation' },
+    { value: '/help', label: '/help', description: 'Show command help' },
+];
+// Content types
+const CONTENT_TYPES = [
+    { value: 'interview', label: 'interview', description: 'User interviews' },
+    { value: 'meeting', label: 'meeting', description: 'Meeting notes' },
+    { value: 'conversation', label: 'conversation', description: 'AI conversations' },
+    { value: 'document', label: 'document', description: 'Documents' },
+    { value: 'note', label: 'note', description: 'Notes' },
+    { value: 'analysis', label: 'analysis', description: 'Analysis documents' },
+];
+// Cache for projects
+let projectsCache = null;
+let projectsCacheTime = 0;
+const CACHE_TTL = 60000; // 1 minute
+/**
+ * Load projects (with caching)
+ */
+async function loadProjects(dbPath) {
+    const now = Date.now();
+    if (projectsCache && now - projectsCacheTime < CACHE_TTL) {
+        return projectsCache.map(p => ({
+            value: p.name,
+            label: p.name,
+            description: `${p.count} docs`,
+        }));
+    }
+    try {
+        const sources = await getAllSources(dbPath, { limit: 1000 });
+        const projectMap = new Map();
+        for (const source of sources) {
+            for (const project of source.projects) {
+                const existing = projectMap.get(project);
+                if (!existing) {
+                    projectMap.set(project, { count: 1, latest: source.created_at });
+                }
+                else {
+                    existing.count++;
+                    if (source.created_at > existing.latest) {
+                        existing.latest = source.created_at;
+                    }
+                }
+            }
+        }
+        projectsCache = Array.from(projectMap.entries())
+            .map(([name, data]) => ({
+            name,
+            count: data.count,
+            latestActivity: data.latest,
+        }))
+            .sort((a, b) => b.count - a.count);
+        projectsCacheTime = now;
+        return projectsCache.map(p => ({
+            value: p.name,
+            label: p.name,
+            description: `${p.count} docs`,
+        }));
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * Update autocomplete based on current input
+ */
+export async function updateAutocomplete(state, ui, dbPath, inputValue) {
+    const trimmed = inputValue.trim();
+    // No autocomplete for empty or non-slash input
+    if (!trimmed.startsWith('/')) {
+        hideAutocomplete(state, ui);
+        return;
+    }
+    // Check if we're typing a command or have completed one
+    const parts = trimmed.split(/\s+/);
+    const cmd = parts[0].toLowerCase();
+    const hasSpace = trimmed.includes(' ');
+    const arg = hasSpace ? parts.slice(1).join(' ') : '';
+    // Project selection: /p <arg> or /project <arg>
+    if ((cmd === '/p' || cmd === '/project') && hasSpace) {
+        const projects = await loadProjects(dbPath);
+        const filtered = arg
+            ? projects.filter(p => p.label.toLowerCase().includes(arg.toLowerCase()))
+            : projects;
+        if (filtered.length > 0) {
+            state.autocompleteType = 'project';
+            state.autocompleteOptions = filtered.slice(0, 8);
+            state.autocompleteIndex = 0;
+            state.autocompleteVisible = true;
+            renderAutocomplete(state, ui);
+        }
+        else {
+            hideAutocomplete(state, ui);
+        }
+        return;
+    }
+    // Type selection: /t <arg> or /type <arg>
+    if ((cmd === '/t' || cmd === '/type') && hasSpace) {
+        const filtered = arg
+            ? CONTENT_TYPES.filter(t => t.label.toLowerCase().includes(arg.toLowerCase()))
+            : CONTENT_TYPES;
+        if (filtered.length > 0) {
+            state.autocompleteType = 'type';
+            state.autocompleteOptions = filtered;
+            state.autocompleteIndex = 0;
+            state.autocompleteVisible = true;
+            renderAutocomplete(state, ui);
+        }
+        else {
+            hideAutocomplete(state, ui);
+        }
+        return;
+    }
+    // Command suggestions: starts with / but no space yet
+    if (!hasSpace) {
+        const filtered = SLASH_COMMANDS.filter(c => c.value.toLowerCase().startsWith(cmd.toLowerCase()));
+        if (filtered.length > 0 && cmd !== filtered[0].value) {
+            // Only show if not exact match
+            state.autocompleteType = 'command';
+            state.autocompleteOptions = filtered;
+            state.autocompleteIndex = 0;
+            state.autocompleteVisible = true;
+            renderAutocomplete(state, ui);
+        }
+        else {
+            hideAutocomplete(state, ui);
+        }
+        return;
+    }
+    hideAutocomplete(state, ui);
+}
+/**
+ * Render the autocomplete dropdown
+ */
+export function renderAutocomplete(state, ui) {
+    if (!state.autocompleteVisible || state.autocompleteOptions.length === 0) {
+        ui.autocompleteDropdown.hide();
+        return;
+    }
+    const lines = [];
+    for (let i = 0; i < state.autocompleteOptions.length; i++) {
+        const opt = state.autocompleteOptions[i];
+        const isSelected = i === state.autocompleteIndex;
+        const prefix = isSelected ? '{inverse}' : '';
+        const suffix = isSelected ? '{/inverse}' : '';
+        const desc = opt.description ? ` {blue-fg}${opt.description}{/blue-fg}` : '';
+        lines.push(`${prefix} ${opt.label}${desc} ${suffix}`);
+    }
+    lines.push('');
+    lines.push('{blue-fg}Up/Down navigate  Tab select  Esc cancel{/blue-fg}');
+    ui.autocompleteDropdown.setContent(lines.join('\n'));
+    // Adjust height based on content
+    const height = Math.min(state.autocompleteOptions.length + 3, 12);
+    ui.autocompleteDropdown.height = height;
+    ui.autocompleteDropdown.show();
+    ui.screen.render();
+}
+/**
+ * Hide the autocomplete dropdown
+ */
+export function hideAutocomplete(state, ui) {
+    if (state.autocompleteVisible) {
+        state.autocompleteVisible = false;
+        state.autocompleteOptions = [];
+        state.autocompleteIndex = 0;
+        state.autocompleteType = null;
+        ui.autocompleteDropdown.hide();
+        ui.screen.render();
+    }
+}
+/**
+ * Navigate autocomplete down
+ */
+export function autocompleteDown(state, ui) {
+    if (!state.autocompleteVisible)
+        return false;
+    if (state.autocompleteIndex < state.autocompleteOptions.length - 1) {
+        state.autocompleteIndex++;
+        renderAutocomplete(state, ui);
+    }
+    return true;
+}
+/**
+ * Navigate autocomplete up
+ */
+export function autocompleteUp(state, ui) {
+    if (!state.autocompleteVisible)
+        return false;
+    if (state.autocompleteIndex > 0) {
+        state.autocompleteIndex--;
+        renderAutocomplete(state, ui);
+    }
+    return true;
+}
+/**
+ * Select current autocomplete option
+ * Returns what was selected so caller can handle appropriately
+ */
+export function autocompleteSelect(state, ui) {
+    if (!state.autocompleteVisible || state.autocompleteOptions.length === 0) {
+        return null;
+    }
+    const selected = state.autocompleteOptions[state.autocompleteIndex];
+    hideAutocomplete(state, ui);
+    switch (state.autocompleteType) {
+        case 'command':
+            // For commands like /p, /t, add a space to trigger next autocomplete
+            if (selected.value === '/p' || selected.value === '/project' ||
+                selected.value === '/t' || selected.value === '/type') {
+                return { type: 'input', value: selected.value + ' ' };
+            }
+            else {
+                return { type: 'input', value: selected.value };
+            }
+        case 'project':
+            // Directly return project name for immediate application
+            return { type: 'project', value: selected.value };
+        case 'type':
+            // Directly return type for immediate application
+            return { type: 'contentType', value: selected.value };
+        default:
+            return null;
+    }
+}
+/**
+ * Check if autocomplete handled a key event
+ * Returns true if the key was handled (should not propagate)
+ */
+export function handleAutocompleteKey(state, ui, key) {
+    if (!state.autocompleteVisible) {
+        return { handled: false };
+    }
+    switch (key) {
+        case 'down':
+            autocompleteDown(state, ui);
+            return { handled: true };
+        case 'up':
+            autocompleteUp(state, ui);
+            return { handled: true };
+        case 'tab':
+        case 'return': {
+            const result = autocompleteSelect(state, ui);
+            if (result !== null) {
+                return { handled: true, result };
+            }
+            return { handled: false };
+        }
+        case 'escape':
+            hideAutocomplete(state, ui);
+            return { handled: true };
+        default:
+            return { handled: false };
+    }
+}