@getlore/cli 0.2.0

package/dist/core/vector-store.js

@@ -0,0 +1,503 @@
+/**
+ * Lore - Vector Store (Supabase + pgvector)
+ *
+ * Cloud-hosted vector storage for semantic search across sources and chunks.
+ * Replaces LanceDB for multi-machine, multi-agent support.
+ */
+import { createClient } from '@supabase/supabase-js';
+import { getValidSession } from './auth.js';
+let supabase = null;
+let supabaseMode = null;
+/**
+ * Get an authenticated Supabase client. Three modes:
+ * 1. Service key (env var set) → bypasses RLS, backward compatible
+ * 2. Authenticated user → publishable key + auth session token → RLS applies
+ * 3. Neither → throws with helpful message
+ */
+export async function getSupabase() {
+    if (supabase)
+        return supabase;
+    const url = process.env.SUPABASE_URL;
+    const serviceKey = process.env.SUPABASE_SERVICE_KEY;
+    const publishableKey = process.env.SUPABASE_PUBLISHABLE_KEY || process.env.SUPABASE_ANON_KEY;
+    if (!url) {
+        throw new Error('SUPABASE_URL is required. Run \'lore setup\' to configure.');
+    }
+    // Mode 1: Service key (bypasses RLS)
+    if (serviceKey) {
+        supabase = createClient(url, serviceKey);
+        supabaseMode = 'service';
+        return supabase;
+    }
+    // Mode 2: Authenticated user (RLS applies)
+    if (publishableKey) {
+        const session = await getValidSession();
+        if (session) {
+            supabase = createClient(url, publishableKey, {
+                global: {
+                    headers: {
+                        Authorization: `Bearer ${session.access_token}`,
+                    },
+                },
+            });
+            supabaseMode = 'auth';
+            return supabase;
+        }
+    }
+    // Mode 3: No auth
+    throw new Error('Not authenticated. Run \'lore login\' to sign in, or set SUPABASE_SERVICE_KEY for service mode.');
+}
+// ============================================================================
+// Index Management (compatibility layer - not needed for Supabase)
+// ============================================================================
+export async function indexExists(_dbPath) {
+    // With Supabase, the index always "exists" if we can connect
+    try {
+        const client = await getSupabase();
+        const { error } = await client.from('sources').select('id').limit(1);
+        return !error;
+    }
+    catch {
+        return false;
+    }
+}
+export async function initializeTables(_dbPath) {
+    // Tables are managed via migrations in Supabase
+    // This is a no-op for compatibility
+}
+export function resetDatabaseConnection() {
+    // Reset the client to force reconnection
+    supabase = null;
+    supabaseMode = null;
+}
+export async function closeDatabase() {
+    supabase = null;
+    supabaseMode = null;
+}
+// For compatibility - Supabase doesn't use a local path
+export async function getDatabase(_dbPath) {
+    return await getSupabase();
+}
+// ============================================================================
+// Source Storage
+// ============================================================================
+export async function addSource(_dbPath, source, vector, extras) {
+    const client = await getSupabase();
+    const record = {
+        id: source.id,
+        title: source.title,
+        source_type: source.source_type,
+        content_type: source.content_type,
+        projects: JSON.parse(source.projects),
+        tags: JSON.parse(source.tags),
+        created_at: source.created_at,
+        summary: source.summary,
+        themes_json: JSON.parse(source.themes_json),
+        quotes_json: JSON.parse(source.quotes_json),
+        has_full_content: source.has_full_content,
+        embedding: vector,
+        indexed_at: new Date().toISOString(),
+    };
+    // Add optional dedup and metadata fields
+    if (extras?.content_hash) {
+        record.content_hash = extras.content_hash;
+    }
+    if (extras?.source_path) {
+        record.source_path = extras.source_path;
+    }
+    if (extras?.source_url) {
+        record.source_url = extras.source_url;
+    }
+    if (extras?.source_name) {
+        record.source_name = extras.source_name;
+    }
+    const { error } = await client.from('sources').upsert(record, {
+        ignoreDuplicates: true,
+    });
+    if (error) {
+        // Duplicate content_hash for this user — document already exists, skip silently
+        if (error.code === '23505') {
+            return;
+        }
+        console.error('[addSource] Error:', error);
+        throw error;
+    }
+}
+export async function storeSources(_dbPath, sources) {
+    const client = await getSupabase();
+    const records = sources.map(({ source, vector, extras }) => {
+        const record = {
+            id: source.id,
+            title: source.title,
+            source_type: source.source_type,
+            content_type: source.content_type,
+            projects: JSON.parse(source.projects),
+            tags: JSON.parse(source.tags),
+            created_at: source.created_at,
+            summary: source.summary,
+            themes_json: JSON.parse(source.themes_json),
+            quotes_json: JSON.parse(source.quotes_json),
+            has_full_content: source.has_full_content,
+            embedding: vector,
+            indexed_at: new Date().toISOString(),
+        };
+        if (extras?.content_hash) {
+            record.content_hash = extras.content_hash;
+        }
+        if (extras?.source_path) {
+            record.source_path = extras.source_path;
+        }
+        if (extras?.source_url) {
+            record.source_url = extras.source_url;
+        }
+        if (extras?.source_name) {
+            record.source_name = extras.source_name;
+        }
+        return record;
+    });
+    const { error } = await client.from('sources').upsert(records);
+    if (error) {
+        console.error('[storeSources] Error:', error);
+        throw error;
+    }
+}
+// ============================================================================
+// Source Path Operations (for edit detection)
+// ============================================================================
+export async function findSourceByPath(_dbPath, sourcePath) {
+    const client = await getSupabase();
+    const { data, error } = await client
+        .from('sources')
+        .select('id, content_hash')
+        .eq('source_path', sourcePath)
+        .limit(1)
+        .single();
+    if (error || !data) {
+        return null;
+    }
+    return {
+        id: data.id,
+        content_hash: data.content_hash,
+    };
+}
+export async function getSourcePathMappings(_dbPath, paths) {
+    if (paths.length === 0)
+        return new Map();
+    const client = await getSupabase();
+    const mappings = new Map();
+    // Query in batches
+    const batchSize = 100;
+    for (let i = 0; i < paths.length; i += batchSize) {
+        const batch = paths.slice(i, i + batchSize);
+        const { data, error } = await client
+            .from('sources')
+            .select('id, source_path, content_hash')
+            .in('source_path', batch);
+        if (error) {
+            console.error('Error getting source path mappings:', error);
+            continue;
+        }
+        for (const row of data || []) {
+            if (row.source_path) {
+                mappings.set(row.source_path, {
+                    id: row.id,
+                    content_hash: row.content_hash,
+                });
+            }
+        }
+    }
+    return mappings;
+}
+// ============================================================================
+// Content Hash Operations (for deduplication)
+// ============================================================================
+export async function checkContentHashExists(_dbPath, contentHash) {
+    const client = await getSupabase();
+    const { data, error } = await client
+        .from('sources')
+        .select('id')
+        .eq('content_hash', contentHash)
+        .limit(1);
+    if (error) {
+        console.error('Error checking content hash:', error);
+        return false;
+    }
+    return (data?.length || 0) > 0;
+}
+export async function getExistingContentHashes(_dbPath, hashes) {
+    if (hashes.length === 0)
+        return new Set();
+    const client = await getSupabase();
+    const existing = new Set();
+    // Query in batches to avoid limits
+    const batchSize = 100;
+    for (let i = 0; i < hashes.length; i += batchSize) {
+        const batch = hashes.slice(i, i + batchSize);
+        const { data, error } = await client
+            .from('sources')
+            .select('content_hash')
+            .in('content_hash', batch);
+        if (error) {
+            console.error('Error checking content hashes:', error);
+            continue;
+        }
+        for (const row of data || []) {
+            if (row.content_hash) {
+                existing.add(row.content_hash);
+            }
+        }
+    }
+    return existing;
+}
+export async function searchSources(_dbPath, queryVector, options = {}) {
+    const { limit = 10, project, source_type, content_type, recency_boost = 0.15, mode = 'hybrid', queryText = '', rrf_k = 60, } = options;
+    const client = await getSupabase();
+    // For backward compatibility: use legacy search if no query text or semantic-only
+    if (mode === 'semantic' || !queryText) {
+        const { data, error } = await client.rpc('search_sources', {
+            query_embedding: queryVector,
+            match_count: limit,
+            filter_project: project || null,
+            filter_source_type: source_type || null,
+            filter_content_type: content_type || null,
+            recency_boost,
+        });
+        if (error) {
+            console.error('Error searching sources:', error);
+            return [];
+        }
+        return (data || []).map((row) => ({
+            id: row.id,
+            title: row.title,
+            source_type: row.source_type,
+            content_type: row.content_type,
+            projects: row.projects,
+            tags: row.tags,
+            created_at: row.created_at,
+            summary: row.summary,
+            themes: (row.themes_json || []),
+            quotes: (row.quotes_json || []),
+            score: row.score,
+        }));
+    }
+    // Use hybrid search RPC
+    const { data, error } = await client.rpc('search_sources_hybrid', {
+        query_embedding: queryVector,
+        query_text: queryText,
+        match_count: limit,
+        filter_project: project || null,
+        filter_source_type: source_type || null,
+        filter_content_type: content_type || null,
+        recency_boost,
+        search_mode: mode,
+        rrf_k,
+    });
+    if (error) {
+        // Fall back to legacy search if hybrid RPC doesn't exist
+        if (error.message?.includes('function search_sources_hybrid') || error.code === '42883') {
+            console.warn('Hybrid search not available, falling back to semantic search');
+            return searchSources(_dbPath, queryVector, { ...options, mode: 'semantic' });
+        }
+        console.error('Error in hybrid search:', error);
+        return [];
+    }
+    return (data || []).map((row) => ({
+        id: row.id,
+        title: row.title,
+        source_type: row.source_type,
+        content_type: row.content_type,
+        projects: row.projects,
+        tags: row.tags,
+        created_at: row.created_at,
+        summary: row.summary,
+        themes: (row.themes_json || []),
+        quotes: (row.quotes_json || []),
+        score: row.score,
+        semantic_rank: row.semantic_rank,
+        keyword_rank: row.keyword_rank,
+    }));
+}
+// ============================================================================
+// Retrieval Operations
+// ============================================================================
+export async function getAllSources(_dbPath, options = {}) {
+    const { project, source_type, limit } = options;
+    const client = await getSupabase();
+    let query = client
+        .from('sources')
+        .select('id, title, source_type, content_type, projects, created_at, summary')
+        .order('created_at', { ascending: false });
+    if (source_type) {
+        query = query.eq('source_type', source_type);
+    }
+    if (project) {
+        query = query.contains('projects', [project]);
+    }
+    if (limit) {
+        query = query.limit(limit);
+    }
+    const { data, error } = await query;
+    if (error) {
+        console.error('Error getting all sources:', error);
+        return [];
+    }
+    return (data || []).map((row) => ({
+        id: row.id,
+        title: row.title,
+        source_type: row.source_type,
+        content_type: row.content_type,
+        projects: row.projects,
+        created_at: row.created_at,
+        summary: row.summary,
+    }));
+}
+export async function getSourceById(_dbPath, sourceId) {
+    const client = await getSupabase();
+    const { data, error } = await client
+        .from('sources')
+        .select('*')
+        .eq('id', sourceId)
+        .single();
+    if (error || !data) {
+        console.error('Error getting source by ID:', error);
+        return null;
+    }
+    return {
+        id: data.id,
+        title: data.title,
+        source_type: data.source_type,
+        content_type: data.content_type,
+        projects: data.projects,
+        tags: data.tags,
+        created_at: data.created_at,
+        summary: data.summary,
+        themes: data.themes_json || [],
+        quotes: data.quotes_json || [],
+        source_url: data.source_url || undefined,
+        source_name: data.source_name || undefined,
+    };
+}
+export async function deleteSource(_dbPath, sourceId) {
+    const client = await getSupabase();
+    // Fetch content_hash and source_path before deleting so callers can
+    // record the hash in the blocklist and remove the original file
+    const { data } = await client
+        .from('sources')
+        .select('content_hash, source_path')
+        .eq('id', sourceId)
+        .single();
+    const contentHash = data?.content_hash;
+    const sourcePath = data?.source_path;
+    const { error } = await client
+        .from('sources')
+        .delete()
+        .eq('id', sourceId);
+    if (error) {
+        console.error('Error deleting source:', error);
+        return { deleted: false };
+    }
+    return { deleted: true, contentHash, sourcePath };
+}
+/**
+ * Update a source's projects array
+ */
+export async function updateSourceProjects(_dbPath, sourceId, projects) {
+    const client = await getSupabase();
+    const { error } = await client
+        .from('sources')
+        .update({ projects })
+        .eq('id', sourceId);
+    if (error) {
+        console.error('Error updating source projects:', error);
+        return false;
+    }
+    return true;
+}
+/**
+ * Update a source's title
+ */
+export async function updateSourceTitle(_dbPath, sourceId, title) {
+    const client = await getSupabase();
+    const { error } = await client
+        .from('sources')
+        .update({ title })
+        .eq('id', sourceId);
+    if (error) {
+        console.error('Error updating source title:', error);
+        return false;
+    }
+    return true;
+}
+/**
+ * Update a source's content type
+ */
+export async function updateSourceContentType(_dbPath, sourceId, contentType) {
+    const client = await getSupabase();
+    const { error } = await client
+        .from('sources')
+        .update({ content_type: contentType })
+        .eq('id', sourceId);
+    if (error) {
+        console.error('Error updating source content type:', error);
+        return false;
+    }
+    return true;
+}
+// ============================================================================
+// Statistics
+// ============================================================================
+export async function getThemeStats(_dbPath, project) {
+    const client = await getSupabase();
+    const stats = new Map();
+    let query = client.from('sources').select('themes_json, quotes_json, projects');
+    if (project) {
+        query = query.contains('projects', [project]);
+    }
+    const { data, error } = await query;
+    if (error) {
+        console.error('Error getting theme stats:', error);
+        return stats;
+    }
+    for (const row of data || []) {
+        const themes = (row.themes_json || []);
+        for (const theme of themes) {
+            const existing = stats.get(theme.name) || { source_count: 0, quote_count: 0 };
+            existing.source_count++;
+            existing.quote_count += theme.evidence?.length || 0;
+            stats.set(theme.name, existing);
+        }
+    }
+    return stats;
+}
+export async function getProjectStats(_dbPath) {
+    const client = await getSupabase();
+    const projectMap = new Map();
+    const { data, error } = await client
+        .from('sources')
+        .select('projects, quotes_json, created_at');
+    if (error) {
+        console.error('Error getting project stats:', error);
+        return [];
+    }
+    for (const row of data || []) {
+        const projects = row.projects;
+        const quotes = (row.quotes_json || []);
+        const created_at = row.created_at;
+        for (const project of projects) {
+            const existing = projectMap.get(project) || {
+                source_count: 0,
+                quote_count: 0,
+                latest_activity: created_at,
+            };
+            existing.source_count++;
+            existing.quote_count += quotes.length;
+            if (new Date(created_at) > new Date(existing.latest_activity)) {
+                existing.latest_activity = created_at;
+            }
+            projectMap.set(project, existing);
+        }
+    }
+    return Array.from(projectMap.entries())
+        .map(([project, stats]) => ({ project, ...stats }))
+        .sort((a, b) => new Date(b.latest_activity).getTime() - new Date(a.latest_activity).getTime());
+}

package/dist/daemon-runner.d.ts

@@ -0,0 +1,8 @@
+#!/usr/bin/env node
+/**
+ * Daemon Runner
+ *
+ * This script runs as a background process, handling file watching and periodic sync.
+ * It writes logs to ~/.config/lore/daemon.log and updates status in daemon.status.json.
+ */
+export {};