@getlore/cli 0.2.0

package/dist/core/vector-store-supabase.js

@@ -0,0 +1,295 @@
+/**
+ * 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';
+let supabase = null;
+function getSupabase() {
+    if (!supabase) {
+        const url = process.env.SUPABASE_URL;
+        const key = process.env.SUPABASE_SERVICE_KEY || process.env.SUPABASE_ANON_KEY;
+        if (!url || !key) {
+            throw new Error('SUPABASE_URL and SUPABASE_SERVICE_KEY (or SUPABASE_ANON_KEY) are required');
+        }
+        supabase = createClient(url, key);
+    }
+    return supabase;
+}
+// ============================================================================
+// 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 = 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;
+}
+export async function closeDatabase() {
+    supabase = null;
+}
+// For compatibility - Supabase doesn't use a local path
+export async function getDatabase(_dbPath) {
+    return getSupabase();
+}
+// ============================================================================
+// Source Storage
+// ============================================================================
+export async function addSource(_dbPath, source, vector) {
+    const client = getSupabase();
+    const { error } = await client.from('sources').upsert({
+        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 (error) {
+        console.error('[addSource] Error:', error);
+        throw error;
+    }
+}
+export async function addChunks(_dbPath, chunks) {
+    if (chunks.length === 0)
+        return;
+    const client = getSupabase();
+    const records = chunks.map((chunk) => ({
+        id: chunk.id,
+        source_id: chunk.source_id,
+        content: chunk.content,
+        type: chunk.type,
+        theme_name: chunk.theme_name || null,
+        speaker: chunk.speaker || null,
+        timestamp: chunk.timestamp || null,
+        embedding: chunk.vector,
+        indexed_at: new Date().toISOString(),
+    }));
+    const { error } = await client.from('chunks').upsert(records);
+    if (error) {
+        console.error('[addChunks] Error:', error);
+        throw error;
+    }
+}
+export async function storeSources(_dbPath, sources) {
+    const client = getSupabase();
+    const records = sources.map(({ source, vector }) => ({
+        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(),
+    }));
+    const { error } = await client.from('sources').upsert(records);
+    if (error) {
+        console.error('[storeSources] Error:', error);
+        throw error;
+    }
+}
+export async function storeChunks(_dbPath, chunks) {
+    if (chunks.length === 0)
+        return;
+    await addChunks(_dbPath, chunks);
+}
+// ============================================================================
+// Search Operations
+// ============================================================================
+export async function searchSources(_dbPath, queryVector, options = {}) {
+    const { limit = 10, project, source_type, content_type, recency_boost = 0.15 } = options;
+    const client = getSupabase();
+    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,
+    }));
+}
+export async function searchChunks(_dbPath, queryVector, options = {}) {
+    const { limit = 20, type, theme_name, source_id } = options;
+    const client = getSupabase();
+    const { data, error } = await client.rpc('search_chunks', {
+        query_embedding: queryVector,
+        match_count: limit,
+        filter_type: type || null,
+        filter_theme_name: theme_name || null,
+        filter_source_id: source_id || null,
+    });
+    if (error) {
+        console.error('Error searching chunks:', error);
+        return [];
+    }
+    return (data || []).map((row) => ({
+        id: row.id,
+        source_id: row.source_id,
+        content: row.content,
+        type: row.type,
+        theme_name: (row.theme_name || ''),
+        speaker: (row.speaker || ''),
+        timestamp: (row.timestamp || ''),
+        score: row.score,
+    }));
+}
+// ============================================================================
+// Retrieval Operations
+// ============================================================================
+export async function getAllSources(_dbPath, options = {}) {
+    const { project, source_type, limit } = options;
+    const client = 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 = 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 || [],
+    };
+}
+// ============================================================================
+// Statistics
+// ============================================================================
+export async function getThemeStats(_dbPath, project) {
+    const client = 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 = 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/core/vector-store.d.ts

@@ -0,0 +1,131 @@
+/**
+ * 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 { SupabaseClient } from '@supabase/supabase-js';
+import type { SourceRecord, Quote, Theme, SourceType, ContentType, SearchMode } from './types.js';
+/**
+ * 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 declare function getSupabase(): Promise<SupabaseClient>;
+export declare function indexExists(_dbPath: string): Promise<boolean>;
+export declare function initializeTables(_dbPath: string): Promise<void>;
+export declare function resetDatabaseConnection(): void;
+export declare function closeDatabase(): Promise<void>;
+export declare function getDatabase(_dbPath: string): Promise<SupabaseClient>;
+export declare function addSource(_dbPath: string, source: SourceRecord, vector: number[], extras?: {
+    content_hash?: string;
+    source_path?: string;
+    source_url?: string;
+    source_name?: string;
+}): Promise<void>;
+export declare function storeSources(_dbPath: string, sources: Array<{
+    source: SourceRecord;
+    vector: number[];
+    extras?: {
+        content_hash?: string;
+        source_path?: string;
+        source_url?: string;
+        source_name?: string;
+    };
+}>): Promise<void>;
+export declare function findSourceByPath(_dbPath: string, sourcePath: string): Promise<{
+    id: string;
+    content_hash: string;
+} | null>;
+export declare function getSourcePathMappings(_dbPath: string, paths: string[]): Promise<Map<string, {
+    id: string;
+    content_hash: string;
+}>>;
+export declare function checkContentHashExists(_dbPath: string, contentHash: string): Promise<boolean>;
+export declare function getExistingContentHashes(_dbPath: string, hashes: string[]): Promise<Set<string>>;
+export interface SearchSourcesOptions {
+    limit?: number;
+    project?: string;
+    source_type?: SourceType;
+    content_type?: ContentType;
+    recency_boost?: number;
+    /** Search mode: 'semantic', 'keyword', or 'hybrid' (default) */
+    mode?: SearchMode;
+    /** Query text for keyword search (required for keyword/hybrid modes) */
+    queryText?: string;
+    /** RRF constant for hybrid search (default 60) */
+    rrf_k?: number;
+}
+export interface SearchSourceResult {
+    id: string;
+    title: string;
+    source_type: SourceType;
+    content_type: ContentType;
+    projects: string[];
+    tags: string[];
+    created_at: string;
+    summary: string;
+    themes: Theme[];
+    quotes: Quote[];
+    score: number;
+    /** Rank in semantic search results (only in hybrid mode) */
+    semantic_rank?: number;
+    /** Rank in keyword search results (only in hybrid mode) */
+    keyword_rank?: number;
+}
+export declare function searchSources(_dbPath: string, queryVector: number[], options?: SearchSourcesOptions): Promise<SearchSourceResult[]>;
+export declare function getAllSources(_dbPath: string, options?: {
+    project?: string;
+    source_type?: SourceType;
+    limit?: number;
+}): Promise<Array<{
+    id: string;
+    title: string;
+    source_type: SourceType;
+    content_type: ContentType;
+    projects: string[];
+    created_at: string;
+    summary: string;
+}>>;
+export declare function getSourceById(_dbPath: string, sourceId: string): Promise<{
+    id: string;
+    title: string;
+    source_type: SourceType;
+    content_type: ContentType;
+    projects: string[];
+    tags: string[];
+    created_at: string;
+    summary: string;
+    themes: Theme[];
+    quotes: Quote[];
+    source_url?: string;
+    source_name?: string;
+} | null>;
+export declare function deleteSource(_dbPath: string, sourceId: string): Promise<{
+    deleted: boolean;
+    contentHash?: string;
+    sourcePath?: string;
+}>;
+/**
+ * Update a source's projects array
+ */
+export declare function updateSourceProjects(_dbPath: string, sourceId: string, projects: string[]): Promise<boolean>;
+/**
+ * Update a source's title
+ */
+export declare function updateSourceTitle(_dbPath: string, sourceId: string, title: string): Promise<boolean>;
+/**
+ * Update a source's content type
+ */
+export declare function updateSourceContentType(_dbPath: string, sourceId: string, contentType: string): Promise<boolean>;
+export declare function getThemeStats(_dbPath: string, project?: string): Promise<Map<string, {
+    source_count: number;
+    quote_count: number;
+}>>;
+export declare function getProjectStats(_dbPath: string): Promise<Array<{
+    project: string;
+    source_count: number;
+    quote_count: number;
+    latest_activity: string;
+}>>;