@getlore/cli 0.2.0

package/dist/mcp/handlers/archive-project.js

@@ -0,0 +1,112 @@
+/**
+ * Archive Project Handler - Mark a project as archived
+ *
+ * Archived projects are excluded from search by default but preserved for history.
+ * This is a human-triggered curation action, not automatic.
+ * Auto-pushes to git remote if configured.
+ */
+import { readFile, writeFile, mkdir } from 'fs/promises';
+import path from 'path';
+import { getProjectStats } from '../../core/vector-store.js';
+import { gitCommitAndPush } from '../../core/git.js';
+const ARCHIVED_PROJECTS_FILE = 'archived-projects.json';
+/**
+ * Load archived projects list
+ */
+export async function loadArchivedProjects(dataDir) {
+    const filePath = path.join(dataDir, ARCHIVED_PROJECTS_FILE);
+    try {
+        const content = await readFile(filePath, 'utf-8');
+        return JSON.parse(content);
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * Save archived projects list
+ */
+async function saveArchivedProjects(dataDir, projects) {
+    const filePath = path.join(dataDir, ARCHIVED_PROJECTS_FILE);
+    await mkdir(dataDir, { recursive: true });
+    await writeFile(filePath, JSON.stringify(projects, null, 2));
+}
+/**
+ * Check if a project is archived
+ */
+export async function isProjectArchived(dataDir, project) {
+    const archived = await loadArchivedProjects(dataDir);
+    return archived.some((p) => p.project.toLowerCase() === project.toLowerCase());
+}
+/**
+ * Get archived project info
+ */
+export async function getArchivedProjectInfo(dataDir, project) {
+    const archived = await loadArchivedProjects(dataDir);
+    return archived.find((p) => p.project.toLowerCase() === project.toLowerCase()) || null;
+}
+export async function handleArchiveProject(dbPath, dataDir, args, options = {}) {
+    const { project, reason, successor_project } = args;
+    const { autoPush = true } = options;
+    // Check if project exists
+    const projectStats = await getProjectStats(dbPath);
+    const existingProject = projectStats.find((p) => p.project.toLowerCase() === project.toLowerCase());
+    if (!existingProject) {
+        return {
+            success: false,
+            project,
+            archived_at: new Date().toISOString(),
+            error: `Project "${project}" not found`,
+            sources_affected: 0,
+        };
+    }
+    // Check if already archived
+    const alreadyArchived = await isProjectArchived(dataDir, project);
+    if (alreadyArchived) {
+        return {
+            success: false,
+            project,
+            archived_at: new Date().toISOString(),
+            error: `Project "${project}" is already archived`,
+            sources_affected: 0,
+        };
+    }
+    // Add to archived list
+    const archived = await loadArchivedProjects(dataDir);
+    const archivedProject = {
+        project: existingProject.project, // Use exact case from DB
+        archived_at: new Date().toISOString(),
+        reason,
+        successor_project,
+    };
+    archived.push(archivedProject);
+    await saveArchivedProjects(dataDir, archived);
+    // Auto-push to git if enabled
+    let synced = false;
+    if (autoPush) {
+        const pushResult = await gitCommitAndPush(dataDir, `Archive project: ${existingProject.project}${reason ? ` (${reason})` : ''}`);
+        synced = pushResult.success && (pushResult.message?.includes('pushed') || false);
+    }
+    return {
+        success: true,
+        project: existingProject.project,
+        archived_at: archivedProject.archived_at,
+        reason,
+        successor_project,
+        sources_affected: existingProject.source_count,
+        synced,
+    };
+}
+/**
+ * Unarchive a project (restore to active)
+ */
+export async function handleUnarchiveProject(dataDir, project) {
+    const archived = await loadArchivedProjects(dataDir);
+    const index = archived.findIndex((p) => p.project.toLowerCase() === project.toLowerCase());
+    if (index === -1) {
+        return { success: false, error: `Project "${project}" is not archived` };
+    }
+    archived.splice(index, 1);
+    await saveArchivedProjects(dataDir, archived);
+    return { success: true };
+}

package/dist/mcp/handlers/get-quotes.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Get Quotes Handler - Find quotes with citations
+ */
+import type { ThemeName } from '../../core/types.js';
+interface GetQuotesArgs {
+    query?: string;
+    theme?: ThemeName;
+    project?: string;
+    limit?: number;
+}
+interface QuoteResult {
+    text: string;
+    speaker?: string;
+    timestamp?: string;
+    theme?: string;
+    source: {
+        id: string;
+        title: string;
+        type: string;
+    };
+    relevance_score?: number;
+}
+export declare function handleGetQuotes(dbPath: string, args: GetQuotesArgs): Promise<{
+    quotes: QuoteResult[];
+    total: number;
+}>;
+export {};

package/dist/mcp/handlers/get-quotes.js

@@ -0,0 +1,61 @@
+/**
+ * Get Quotes Handler - Find quotes with citations
+ */
+import { searchChunks, getSourceById } from '../../core/vector-store.js';
+import { generateEmbedding } from '../../core/embedder.js';
+export async function handleGetQuotes(dbPath, args) {
+    const { query, theme, project, limit = 20 } = args;
+    let results = [];
+    if (query) {
+        // Semantic search for quotes
+        const queryVector = await generateEmbedding(query);
+        results = await searchChunks(dbPath, queryVector, {
+            limit,
+            type: 'quote',
+            theme_name: theme,
+        });
+    }
+    else if (theme) {
+        // Just filter by theme (use a generic embedding)
+        const queryVector = await generateEmbedding(`${theme} user feedback`);
+        results = await searchChunks(dbPath, queryVector, {
+            limit: limit * 2,
+            type: 'quote',
+            theme_name: theme,
+        });
+        results = results.slice(0, limit);
+    }
+    else {
+        return { quotes: [], total: 0 };
+    }
+    // Enrich with source info
+    const sourceCache = new Map();
+    const quotes = [];
+    for (const result of results) {
+        // Get source info (with caching)
+        let sourceInfo = sourceCache.get(result.source_id);
+        if (!sourceInfo) {
+            const source = await getSourceById(dbPath, result.source_id);
+            if (source) {
+                sourceInfo = { title: source.title, type: source.source_type };
+                sourceCache.set(result.source_id, sourceInfo);
+            }
+            else {
+                sourceInfo = { title: 'Unknown', type: 'unknown' };
+            }
+        }
+        quotes.push({
+            text: result.content,
+            speaker: result.speaker || undefined,
+            timestamp: result.timestamp || undefined,
+            theme: result.theme_name || undefined,
+            source: {
+                id: result.source_id,
+                title: sourceInfo.title,
+                type: sourceInfo.type,
+            },
+            relevance_score: result.score,
+        });
+    }
+    return { quotes, total: quotes.length };
+}

package/dist/mcp/handlers/get-source.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Get Source Handler - Retrieve full source document details
+ */
+interface GetSourceArgs {
+    source_id: string;
+    include_content?: boolean;
+}
+export declare function handleGetSource(dbPath: string, dataDir: string, args: GetSourceArgs): Promise<unknown>;
+export {};

package/dist/mcp/handlers/get-source.js

@@ -0,0 +1,40 @@
+/**
+ * Get Source Handler - Retrieve full source document details
+ */
+import { getSourceById } from '../../core/vector-store.js';
+import { readFile } from 'fs/promises';
+import path from 'path';
+export async function handleGetSource(dbPath, dataDir, args) {
+    const { source_id, include_content = false } = args;
+    const source = await getSourceById(dbPath, source_id);
+    if (!source) {
+        return { error: `Source not found: ${source_id}` };
+    }
+    const result = {
+        id: source.id,
+        title: source.title,
+        source_type: source.source_type,
+        content_type: source.content_type,
+        projects: source.projects,
+        tags: source.tags,
+        created_at: source.created_at,
+        summary: source.summary,
+        themes: source.themes,
+        quotes: source.quotes,
+        source_url: source.source_url || undefined,
+        source_name: source.source_name || undefined,
+    };
+    // Include full content if requested
+    if (include_content) {
+        try {
+            const contentPath = path.join(dataDir, 'sources', source_id, 'content.md');
+            const content = await readFile(contentPath, 'utf-8');
+            result.full_content = content;
+        }
+        catch {
+            result.full_content = null;
+            result.content_note = 'Full content not available on disk';
+        }
+    }
+    return result;
+}

package/dist/mcp/handlers/ingest.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Ingest Handler - Primary agent-facing surface for pushing content into Lore
+ *
+ * Agents (Claude Code, OpenClaw, ChatGPT, etc.) use this to push content
+ * from external systems (Slack, Notion, GitHub, meetings, etc.) into Lore.
+ * Content is deduplicated by SHA256 hash, saved to disk, and immediately indexed.
+ */
+interface IngestArgs {
+    content: string;
+    title: string;
+    project: string;
+    source_type?: string;
+    date?: string;
+    participants?: string[];
+    tags?: string[];
+    source_url?: string;
+    source_name?: string;
+}
+export declare function handleIngest(dbPath: string, dataDir: string, args: IngestArgs, options?: {
+    autoPush?: boolean;
+    hookContext?: {
+        mode: 'mcp' | 'cli';
+    };
+}): Promise<unknown>;
+export {};

package/dist/mcp/handlers/ingest.js

@@ -0,0 +1,305 @@
+/**
+ * Ingest Handler - Primary agent-facing surface for pushing content into Lore
+ *
+ * Agents (Claude Code, OpenClaw, ChatGPT, etc.) use this to push content
+ * from external systems (Slack, Notion, GitHub, meetings, etc.) into Lore.
+ * Content is deduplicated by SHA256 hash, saved to disk, and immediately indexed.
+ */
+import { writeFile, mkdir } from 'fs/promises';
+import path from 'path';
+import { randomUUID, createHash } from 'crypto';
+import { addSource, checkContentHashExists } from '../../core/vector-store.js';
+import { generateEmbedding, createSearchableText } from '../../core/embedder.js';
+import { extractInsights } from '../../core/insight-extractor.js';
+import { gitCommitAndPush } from '../../core/git.js';
+import { getExtensionRegistry } from '../../extensions/registry.js';
+// Normalize source_type to canonical kebab-case form.
+// Agents pass free-form strings — this ensures consistency for filtering.
+const SOURCE_TYPE_ALIASES = {
+    // Granola
+    'granola': 'meeting',
+    'granola-app': 'meeting',
+    'granola meeting': 'meeting',
+    // Meetings
+    'meeting notes': 'meeting',
+    'meeting-notes': 'meeting',
+    'meetings': 'meeting',
+    // Interviews
+    'interviews': 'interview',
+    'user interview': 'interview',
+    'user-interview': 'interview',
+    // Slack
+    'slack thread': 'slack',
+    'slack-thread': 'slack',
+    'slack message': 'slack',
+    'slack-message': 'slack',
+    // Email
+    'emails': 'email',
+    'email thread': 'email',
+    'email-thread': 'email',
+    // GitHub
+    'github issue': 'github-issue',
+    'github-pr': 'github-pr',
+    'github pull request': 'github-pr',
+    'pull request': 'github-pr',
+    'pull-request': 'github-pr',
+    // Notion
+    'notion page': 'notion',
+    'notion-page': 'notion',
+    // Conversations
+    'conversations': 'conversation',
+    'chat': 'conversation',
+    // Notes
+    'notes': 'notes',
+    'note': 'notes',
+    // Documents
+    'doc': 'document',
+    'docs': 'document',
+    'documents': 'document',
+    'markdown': 'document',
+    'md': 'document',
+    // Articles
+    'blog post': 'article',
+    'blog-post': 'article',
+    'web article': 'article',
+    'web-article': 'article',
+    'online article': 'article',
+    'blog': 'article',
+    'post': 'article',
+    // Media / files
+    'pdf': 'pdf',
+    'pdf document': 'pdf',
+    'docx': 'document',
+    'word doc': 'document',
+    'word document': 'document',
+    'google doc': 'document',
+    'google-doc': 'document',
+    'image': 'image',
+    'screenshot': 'image',
+    'photo': 'image',
+    'diagram': 'image',
+    'video': 'video',
+    'recording': 'video',
+    'loom': 'video',
+    'audio': 'audio',
+    'podcast': 'audio',
+    'voice memo': 'audio',
+    'voice-memo': 'audio',
+    // Specs / RFCs
+    'specification': 'spec',
+    'rfc': 'rfc',
+    'design doc': 'spec',
+    'design-doc': 'spec',
+    // Transcripts
+    'transcript': 'transcript',
+    // Legacy types
+    'claude-code': 'conversation',
+    'claude-desktop': 'conversation',
+    'chatgpt': 'conversation',
+};
+function normalizeSourceType(raw) {
+    if (!raw)
+        return 'document';
+    const key = raw.toLowerCase().trim();
+    return SOURCE_TYPE_ALIASES[key] || key.toLowerCase().replace(/\s+/g, '-');
+}
+// Map source_type to ContentType
+function mapContentType(sourceType) {
+    switch (sourceType) {
+        case 'meeting':
+            return 'meeting';
+        case 'interview':
+            return 'interview';
+        case 'conversation':
+            return 'conversation';
+        case 'analysis':
+            return 'analysis';
+        case 'notes':
+        case 'note':
+            return 'note';
+        case 'document':
+        default:
+            return 'document';
+    }
+}
+export async function handleIngest(dbPath, dataDir, args, options = {}) {
+    const { content, title, project, source_type: raw_source_type, date, participants = [], tags = [], source_url, source_name, } = args;
+    const { autoPush = true, hookContext } = options;
+    const source_type = normalizeSourceType(raw_source_type);
+    // Content hash deduplication — skip everything if already ingested
+    const contentHash = createHash('sha256').update(content).digest('hex');
+    try {
+        const exists = await checkContentHashExists(dbPath, contentHash);
+        if (exists) {
+            return {
+                success: true,
+                deduplicated: true,
+                message: 'Content already exists in the knowledge base (identical content hash).',
+            };
+        }
+    }
+    catch (error) {
+        // If dedup check fails, continue with ingestion rather than blocking
+        console.error('Dedup check failed, continuing with ingestion:', error);
+    }
+    const id = randomUUID();
+    const timestamp = date || new Date().toISOString();
+    const contentType = mapContentType(source_type);
+    // Create source directory structure (matches CLI ingest format)
+    const sourceDir = path.join(dataDir, 'sources', id);
+    await mkdir(sourceDir, { recursive: true });
+    // Save metadata.json
+    const metadata = {
+        id,
+        title,
+        source_type: source_type,
+        content_type: contentType,
+        created_at: timestamp,
+        imported_at: new Date().toISOString(),
+        projects: [project],
+        tags,
+        participants,
+        content_hash: contentHash,
+    };
+    if (source_url) {
+        metadata.source_url = source_url;
+    }
+    if (source_name) {
+        metadata.source_name = source_name;
+    }
+    await writeFile(path.join(sourceDir, 'metadata.json'), JSON.stringify(metadata, null, 2));
+    // Save content.md
+    await writeFile(path.join(sourceDir, 'content.md'), content);
+    // Extract insights using LLM
+    let summary = content.slice(0, 200) + (content.length > 200 ? '...' : '');
+    let themes = [];
+    let quotes = [];
+    try {
+        if (content.trim().length > 100) {
+            const insights = await extractInsights(content, title, id, { contentType });
+            summary = insights.summary;
+            themes = insights.themes.map((t) => ({ name: t.name, quotes: [] }));
+            quotes = insights.quotes.map((q) => ({ text: q.text, speaker: q.speaker }));
+            // Save insights.json
+            await writeFile(path.join(sourceDir, 'insights.json'), JSON.stringify({ summary, themes, quotes }, null, 2));
+        }
+    }
+    catch (error) {
+        console.error('Failed to extract insights:', error);
+        // Continue with basic summary
+    }
+    // Add to vector store immediately
+    try {
+        const searchableText = createSearchableText({
+            type: 'summary',
+            text: summary,
+            project,
+        });
+        const vector = await generateEmbedding(searchableText);
+        const sourceRecord = {
+            id,
+            title,
+            source_type,
+            content_type: contentType,
+            projects: JSON.stringify([project]),
+            tags: JSON.stringify(tags),
+            created_at: timestamp,
+            summary,
+            themes_json: JSON.stringify(themes),
+            quotes_json: JSON.stringify([]),
+            has_full_content: true,
+            vector: [],
+        };
+        await addSource(dbPath, sourceRecord, vector, {
+            content_hash: contentHash,
+            source_url,
+            source_name,
+        });
+        // Auto-push to git if enabled
+        let pushed = false;
+        if (autoPush) {
+            const pushResult = await gitCommitAndPush(dataDir, `Ingest: ${title}`);
+            pushed = pushResult.success && (pushResult.message?.includes('pushed') || false);
+        }
+        const result = {
+            success: true,
+            id,
+            title,
+            project,
+            source_type,
+            filepath: `sources/${id}`,
+            summary,
+            indexed: true,
+            synced: pushed,
+        };
+        await runSourceCreatedHook({
+            id,
+            title,
+            source_type: source_type,
+            content_type: contentType,
+            created_at: timestamp,
+            imported_at: new Date().toISOString(),
+            projects: [project],
+            tags,
+            source_path: path.join(dataDir, 'sources', id),
+            content_hash: contentHash,
+        }, {
+            mode: hookContext?.mode || 'mcp',
+            dataDir,
+            dbPath,
+        });
+        return result;
+    }
+    catch (error) {
+        console.error('Failed to index ingested document:', error);
+        // Still try to push even if indexing failed
+        let pushed = false;
+        if (autoPush) {
+            const pushResult = await gitCommitAndPush(dataDir, `Ingest: ${title}`);
+            pushed = pushResult.success && (pushResult.message?.includes('pushed') || false);
+        }
+        const result = {
+            success: true,
+            id,
+            title,
+            project,
+            source_type,
+            filepath: `sources/${id}`,
+            indexed: false,
+            synced: pushed,
+            note: 'Saved to disk but indexing failed. Run "lore sync" to index.',
+        };
+        await runSourceCreatedHook({
+            id,
+            title,
+            source_type: source_type,
+            content_type: contentType,
+            created_at: timestamp,
+            imported_at: new Date().toISOString(),
+            projects: [project],
+            tags,
+            source_path: path.join(dataDir, 'sources', id),
+            content_hash: contentHash,
+        }, {
+            mode: hookContext?.mode || 'mcp',
+            dataDir,
+            dbPath,
+        });
+        return result;
+    }
+}
+async function runSourceCreatedHook(event, context) {
+    try {
+        const registry = await getExtensionRegistry({
+            logger: (message) => console.error(message),
+        });
+        await registry.runHook('onSourceCreated', event, {
+            mode: context.mode,
+            dataDir: context.dataDir,
+            dbPath: context.dbPath,
+        });
+    }
+    catch (error) {
+        console.error('[extensions] Failed to run onSourceCreated hook:', error);
+    }
+}

package/dist/mcp/handlers/list-projects.d.ts

@@ -0,0 +1,4 @@
+/**
+ * List Projects Handler - Show all projects with stats
+ */
+export declare function handleListProjects(dbPath: string): Promise<unknown>;

package/dist/mcp/handlers/list-projects.js

@@ -0,0 +1,16 @@
+/**
+ * List Projects Handler - Show all projects with stats
+ */
+import { getProjectStats } from '../../core/vector-store.js';
+export async function handleListProjects(dbPath) {
+    const projects = await getProjectStats(dbPath);
+    return {
+        projects: projects.map((p) => ({
+            name: p.project,
+            source_count: p.source_count,
+            quote_count: p.quote_count,
+            latest_activity: p.latest_activity,
+        })),
+        total: projects.length,
+    };
+}

package/dist/mcp/handlers/list-sources.d.ts

@@ -0,0 +1,11 @@
+/**
+ * List Sources Handler - List all sources with optional filtering
+ */
+import type { SourceType } from '../../core/types.js';
+interface ListSourcesArgs {
+    project?: string;
+    source_type?: SourceType;
+    limit?: number;
+}
+export declare function handleListSources(dbPath: string, args: ListSourcesArgs): Promise<unknown>;
+export {};

package/dist/mcp/handlers/list-sources.js

@@ -0,0 +1,20 @@
+/**
+ * List Sources Handler - List all sources with optional filtering
+ */
+import { getAllSources } from '../../core/vector-store.js';
+export async function handleListSources(dbPath, args) {
+    const { project, source_type, limit = 20 } = args;
+    const sources = await getAllSources(dbPath, {
+        project,
+        source_type,
+        limit,
+    });
+    return {
+        sources,
+        total: sources.length,
+        filters: {
+            project: project || 'all',
+            source_type: source_type || 'all',
+        },
+    };
+}

package/dist/mcp/handlers/research-agent.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Lore - Agentic Research using Claude Agent SDK
+ *
+ * This is the "real" agent that:
+ * 1. Takes a research task
+ * 2. Uses Lore's own tools iteratively (search, get_source, list_sources)
+ * 3. Follows leads, cross-references, refines queries
+ * 4. Synthesizes findings into a comprehensive research package
+ */
+import type { ResearchPackage } from '../../core/types.js';
+interface ResearchAgentArgs {
+    task: string;
+    project?: string;
+    content_type?: string;
+    include_sources?: boolean;
+}
+/**
+ * Run the agentic research
+ */
+export declare function runResearchAgent(dbPath: string, dataDir: string, args: ResearchAgentArgs): Promise<ResearchPackage>;
+export {};