@getlore/cli 0.2.0

package/dist/cli/commands/misc.js

@@ -0,0 +1,172 @@
+/**
+ * Miscellaneous CLI Commands
+ *
+ * browse, research, init, serve
+ */
+import path from 'path';
+export function registerMiscCommands(program, defaultDataDir) {
+    // Browse command (TUI)
+    program
+        .command('browse')
+        .description('Browse documents in an interactive terminal UI')
+        .option('-p, --project <project>', 'Filter by project')
+        .option('-t, --type <type>', 'Filter by source type')
+        .option('-l, --limit <limit>', 'Max documents to load', '100')
+        .option('-d, --data-dir <dir>', 'Data directory', defaultDataDir)
+        .action(async (options) => {
+        const { startBrowser } = await import('../../tui/browse.js');
+        await startBrowser({
+            project: options.project,
+            sourceType: options.type,
+            limit: parseInt(options.limit, 10),
+            dataDir: options.dataDir,
+        });
+    });
+    // Research command (top-level for discoverability)
+    program
+        .command('research')
+        .description('Deep AI-powered research on a topic')
+        .argument('<query>', 'Research query')
+        .option('-p, --project <project>', 'Focus on specific project')
+        .option('-d, --data-dir <dir>', 'Data directory', defaultDataDir)
+        .option('--simple', 'Use simple mode (single-pass, faster)')
+        .action(async (query, options) => {
+        const { handleResearch } = await import('../../mcp/handlers/research.js');
+        const dataDir = options.dataDir;
+        const dbPath = path.join(dataDir, 'lore.lance');
+        if (options.simple) {
+            process.env.LORE_RESEARCH_MODE = 'simple';
+        }
+        console.log(`\nResearching: "${query}"\n`);
+        console.log('This may take a moment...\n');
+        const result = await handleResearch(dbPath, dataDir, {
+            task: query,
+            project: options.project,
+            include_sources: true,
+        }, {
+            hookContext: { mode: 'cli' },
+        });
+        console.log(`━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━`);
+        console.log(`📊 Research Results`);
+        console.log(`━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n`);
+        console.log(`Summary:\n${result.summary}\n`);
+        if (result.key_findings && result.key_findings.length > 0) {
+            console.log(`Key Findings:`);
+            for (const finding of result.key_findings) {
+                console.log(`  • ${finding}`);
+            }
+            console.log('');
+        }
+        if (result.conflicts_resolved && result.conflicts_resolved.length > 0) {
+            console.log(`Conflicts Resolved:`);
+            for (const conflict of result.conflicts_resolved) {
+                console.log(`  ⚡ ${conflict}`);
+            }
+            console.log('');
+        }
+        if (result.supporting_quotes && result.supporting_quotes.length > 0) {
+            console.log(`Supporting Quotes (${result.supporting_quotes.length}):`);
+            for (const quote of result.supporting_quotes.slice(0, 5)) {
+                const speaker = quote.speaker === 'user' ? '[You]' : '[Participant]';
+                console.log(`  ${speaker} "${quote.text.substring(0, 80)}${quote.text.length > 80 ? '...' : ''}"`);
+            }
+            if (result.supporting_quotes.length > 5) {
+                console.log(`  ... and ${result.supporting_quotes.length - 5} more`);
+            }
+            console.log('');
+        }
+        if (result.sources_consulted && result.sources_consulted.length > 0) {
+            console.log(`Sources Consulted (${result.sources_consulted.length}):`);
+            for (const source of result.sources_consulted.slice(0, 5)) {
+                const relevance = source.relevance ? ` (${(source.relevance * 100).toFixed(0)}%)` : '';
+                console.log(`  • ${source.title}${relevance}`);
+            }
+            if (result.sources_consulted.length > 5) {
+                console.log(`  ... and ${result.sources_consulted.length - 5} more`);
+            }
+            console.log('');
+        }
+        if (result.gaps_identified && result.gaps_identified.length > 0) {
+            console.log(`Gaps Identified:`);
+            for (const gap of result.gaps_identified) {
+                console.log(`  ? ${gap}`);
+            }
+            console.log('');
+        }
+        if (result.suggested_queries && result.suggested_queries.length > 0) {
+            console.log(`Suggested Follow-up Queries:`);
+            for (const q of result.suggested_queries) {
+                console.log(`  → ${q}`);
+            }
+            console.log('');
+        }
+    });
+    // Init command
+    program
+        .command('init')
+        .description('Initialize a new Lore data repository')
+        .argument('[path]', 'Path for the data repository', '~/.lore')
+        .option('--remote <url>', 'Git remote URL for cross-machine sync')
+        .action(async (targetPath, options) => {
+        const { initDataRepo, getGitRemoteUrl } = await import('../../core/data-repo.js');
+        const { execSync } = await import('child_process');
+        // Expand ~ to home directory
+        const expandedPath = targetPath.replace(/^~/, process.env.HOME || '~');
+        console.log(`\nLore Init`);
+        console.log(`=========`);
+        console.log(`Creating data repository at: ${expandedPath}\n`);
+        await initDataRepo(expandedPath);
+        console.log('✓ Created data repository');
+        // Add remote if provided
+        if (options.remote) {
+            try {
+                execSync(`git remote add origin ${options.remote}`, { cwd: expandedPath, stdio: 'pipe' });
+                console.log(`✓ Added remote: ${options.remote}`);
+                try {
+                    execSync('git push -u origin main', { cwd: expandedPath, stdio: 'pipe' });
+                    console.log('✓ Pushed to remote');
+                }
+                catch {
+                    console.log('⚠ Could not push to remote (you may need to push manually)');
+                }
+            }
+            catch {
+                // Remote may already exist
+                const existing = getGitRemoteUrl(expandedPath);
+                if (existing) {
+                    console.log(`✓ Remote already set: ${existing}`);
+                }
+            }
+        }
+        console.log(`
+Done! To use this data repository:
+
+1. Set the environment variable:
+   export LORE_DATA_DIR=${expandedPath}
+
+2. Or add to your MCP config:
+   "env": { "LORE_DATA_DIR": "${expandedPath}" }
+
+3. Add sync sources:
+   lore sync add --name "My Notes" --path ~/notes --glob "**/*.md" -p myproject
+
+Tip: Run 'lore setup' for the full guided experience (config + login + data repo).
+`);
+    });
+    // MCP server command
+    program
+        .command('mcp')
+        .description('Start the MCP server')
+        .option('-w, --watch', 'Watch extensions and auto-reload')
+        .option('--sandbox', 'Run extension tools in worker thread sandbox')
+        .action(async (options) => {
+        if (options.watch) {
+            process.env.LORE_EXTENSION_WATCH = 'true';
+        }
+        if (options.sandbox) {
+            process.env.LORE_EXTENSION_SANDBOX = 'true';
+        }
+        // Dynamic import to start MCP server
+        await import('../../mcp/server.js');
+    });
+}

package/dist/cli/commands/pending.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Pending proposals CLI commands
+ *
+ * lore pending list|show|approve|reject
+ */
+import type { Command } from 'commander';
+export declare function registerPendingCommand(extensionCmd: Command, defaultDataDir: string): void;

package/dist/cli/commands/pending.js

@@ -0,0 +1,63 @@
+/**
+ * Pending proposals CLI commands
+ *
+ * lore pending list|show|approve|reject
+ */
+import path from 'path';
+import { listPendingProposals, getProposal, approveProposal, rejectProposal, } from '../../extensions/proposals.js';
+function formatProposalSummary(entry) {
+    const date = new Date(entry.createdAt).toLocaleString();
+    return `${entry.id}  ${entry.status}  ${entry.extensionName}  ${entry.change.type}  ${date}`;
+}
+export function registerPendingCommand(extensionCmd, defaultDataDir) {
+    const pending = extensionCmd
+        .command('pending')
+        .description('Review and approve extension write proposals');
+    pending
+        .command('list')
+        .description('List pending proposals')
+        .action(async () => {
+        const proposals = await listPendingProposals();
+        if (proposals.length === 0) {
+            console.log('No pending proposals.');
+            return;
+        }
+        console.log('ID  Status  Extension  Type  Created');
+        console.log('──────────────────────────────────────────────');
+        for (const proposal of proposals) {
+            console.log(formatProposalSummary(proposal));
+        }
+    });
+    pending
+        .command('show')
+        .description('Show proposal details')
+        .argument('<id>', 'Proposal ID')
+        .action(async (id) => {
+        const proposal = await getProposal(id);
+        if (!proposal) {
+            console.error(`Proposal not found: ${id}`);
+            process.exit(1);
+        }
+        console.log(JSON.stringify(proposal, null, 2));
+    });
+    pending
+        .command('approve')
+        .description('Approve and apply a proposal')
+        .argument('<id>', 'Proposal ID')
+        .option('-d, --data-dir <dir>', 'Data directory', defaultDataDir)
+        .action(async (id, options) => {
+        const dataDir = options.dataDir;
+        const dbPath = path.join(dataDir, 'lore.lance');
+        await approveProposal(id, dbPath, dataDir);
+        console.log(`Approved proposal ${id}`);
+    });
+    pending
+        .command('reject')
+        .description('Reject a proposal')
+        .argument('<id>', 'Proposal ID')
+        .option('-r, --reason <reason>', 'Rejection reason', 'Rejected by user')
+        .action(async (id, options) => {
+        await rejectProposal(id, options.reason);
+        console.log(`Rejected proposal ${id}`);
+    });
+}

package/dist/cli/commands/projects.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Projects CLI Commands
+ *
+ * Project management: list, archive, delete
+ */
+import type { Command } from 'commander';
+export declare function registerProjectsCommand(program: Command, defaultDataDir: string): void;

package/dist/cli/commands/projects.js

@@ -0,0 +1,136 @@
+/**
+ * Projects CLI Commands
+ *
+ * Project management: list, archive, delete
+ */
+import path from 'path';
+import { indexExists } from '../../core/vector-store.js';
+export function registerProjectsCommand(program, defaultDataDir) {
+    const projectsCmd = program
+        .command('projects')
+        .description('Project management');
+    // List projects (default action)
+    projectsCmd
+        .command('list', { isDefault: true })
+        .description('List all projects')
+        .option('-d, --data-dir <dir>', 'Data directory', defaultDataDir)
+        .action(async (options) => {
+        const dataDir = options.dataDir;
+        const dbPath = path.join(dataDir, 'lore.lance');
+        if (!(await indexExists(dbPath))) {
+            console.log('No index found. Run "lore sync" first.');
+            process.exit(1);
+        }
+        const { getProjectStats } = await import('../../core/vector-store.js');
+        const projects = await getProjectStats(dbPath);
+        console.log(`\nProjects (${projects.length}):`);
+        console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
+        if (projects.length === 0) {
+            console.log('No projects found.');
+            return;
+        }
+        for (const p of projects) {
+            console.log(`\n📁 ${p.project}`);
+            console.log(`   Sources: ${p.source_count} | Quotes: ${p.quote_count}`);
+            console.log(`   Latest: ${new Date(p.latest_activity).toLocaleDateString()}`);
+        }
+        console.log('');
+    });
+    // Archive project
+    projectsCmd
+        .command('archive')
+        .description('Archive a project (hide from search)')
+        .argument('<name>', 'Project name to archive')
+        .option('-r, --reason <reason>', 'Reason for archiving')
+        .option('-s, --successor <project>', 'Successor project name')
+        .option('-d, --data-dir <dir>', 'Data directory', defaultDataDir)
+        .option('--no-push', 'Skip git push')
+        .action(async (projectName, options) => {
+        const { handleArchiveProject } = await import('../../mcp/handlers/archive-project.js');
+        const dataDir = options.dataDir;
+        const dbPath = path.join(dataDir, 'lore.lance');
+        const result = await handleArchiveProject(dbPath, dataDir, {
+            project: projectName,
+            reason: options.reason,
+            successor_project: options.successor,
+        }, { autoPush: options.push !== false });
+        if (result.success) {
+            console.log(`\n✓ Archived project "${result.project}"`);
+            console.log(`  Sources affected: ${result.sources_affected}`);
+            if (result.reason)
+                console.log(`  Reason: ${result.reason}`);
+            if (result.successor_project)
+                console.log(`  Successor: ${result.successor_project}`);
+            console.log(`  Synced: ${result.synced ? 'yes' : 'no'}`);
+        }
+        else {
+            console.error(`\nFailed to archive: ${result.error}`);
+            process.exit(1);
+        }
+    });
+    // Delete project
+    projectsCmd
+        .command('delete')
+        .description('Delete a project and all its documents')
+        .argument('<name>', 'Project name to delete')
+        .option('-d, --data-dir <dir>', 'Data directory', defaultDataDir)
+        .option('--force', 'Skip confirmation')
+        .action(async (projectName, options) => {
+        const dataDir = options.dataDir;
+        const dbPath = path.join(dataDir, 'lore.lance');
+        if (!(await indexExists(dbPath))) {
+            console.log('No index found. Run "lore sync" first.');
+            process.exit(1);
+        }
+        // Get project stats first
+        const { getProjectStats, getAllSources, deleteSource } = await import('../../core/vector-store.js');
+        const projects = await getProjectStats(dbPath);
+        const project = projects.find(p => p.project === projectName);
+        if (!project) {
+            console.error(`Project not found: ${projectName}`);
+            process.exit(1);
+        }
+        if (!options.force) {
+            const readline = await import('readline');
+            const rl = readline.createInterface({
+                input: process.stdin,
+                output: process.stdout,
+            });
+            console.log(`\nThis will delete project "${projectName}" and all ${project.source_count} documents.`);
+            const answer = await new Promise((resolve) => {
+                rl.question('Are you sure? (type "yes" to confirm) ', resolve);
+            });
+            rl.close();
+            if (answer !== 'yes') {
+                console.log('Cancelled.');
+                return;
+            }
+        }
+        // Get all sources in this project
+        const sources = await getAllSources(dbPath, { project: projectName });
+        // Delete each source
+        const { rm } = await import('fs/promises');
+        const { deleteFileAndCommit, gitCommitAndPush } = await import('../../core/git.js');
+        let deleted = 0;
+        for (const source of sources) {
+            const { sourcePath: originalPath } = await deleteSource(dbPath, source.id);
+            // Delete from disk (lore-data copy)
+            const loreSourcePath = path.join(dataDir, 'sources', source.id);
+            try {
+                await rm(loreSourcePath, { recursive: true });
+            }
+            catch {
+                // File may not exist on disk
+            }
+            // Delete original source file from sync directory (and commit to its repo)
+            if (originalPath) {
+                await deleteFileAndCommit(originalPath, `Delete: ${source.title.slice(0, 50)}`);
+            }
+            deleted++;
+        }
+        // Git commit the lore-data changes
+        await gitCommitAndPush(dataDir, `Delete project: ${projectName} (${deleted} documents)`);
+        console.log(`\n✓ Deleted project "${projectName}"`);
+        console.log(`  Documents deleted: ${deleted}`);
+    });
+}

package/dist/cli/commands/search.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Search Command
+ *
+ * Search the knowledge repository with various modes.
+ */
+import type { Command } from 'commander';
+export declare function registerSearchCommand(program: Command, defaultDataDir: string): void;

package/dist/cli/commands/search.js

@@ -0,0 +1,102 @@
+/**
+ * Search Command
+ *
+ * Search the knowledge repository with various modes.
+ */
+import path from 'path';
+import { indexExists, searchSources, getSourceById } from '../../core/vector-store.js';
+import { generateEmbedding } from '../../core/embedder.js';
+export function registerSearchCommand(program, defaultDataDir) {
+    program
+        .command('search')
+        .description('Search the knowledge repository')
+        .argument('<query>', 'Search query')
+        .option('-p, --project <project>', 'Filter by project')
+        .option('-l, --limit <limit>', 'Max results', '5')
+        .option('-m, --mode <mode>', 'Search mode: semantic, keyword, hybrid (default), regex', 'hybrid')
+        .option('-d, --data-dir <dir>', 'Data directory', defaultDataDir)
+        .action(async (query, options) => {
+        const dataDir = options.dataDir;
+        const dbPath = path.join(dataDir, 'lore.lance');
+        const searchMode = options.mode;
+        try {
+            if (!(await indexExists(dbPath))) {
+                console.log('No index found. Run "lore ingest" first.');
+                process.exit(1);
+            }
+            console.log(`\nSearching for: "${query}" (mode: ${searchMode})\n`);
+            // Handle regex mode separately
+            if (searchMode === 'regex') {
+                const { searchLocalFiles, getMatchSnippet } = await import('../../core/local-search.js');
+                const results = await searchLocalFiles(dataDir, query, {
+                    maxTotalResults: parseInt(options.limit),
+                    maxMatchesPerFile: 5,
+                });
+                if (results.length === 0) {
+                    console.log('No regex matches found.');
+                    return;
+                }
+                for (const result of results) {
+                    const sourceData = await getSourceById(dbPath, result.source_id);
+                    console.log(`━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━`);
+                    console.log(`📄 ${sourceData?.title || result.source_id}`);
+                    if (sourceData) {
+                        console.log(`   Type: ${sourceData.source_type} | ${sourceData.content_type}`);
+                        console.log(`   Projects: ${sourceData.projects.join(', ') || '(none)'}`);
+                    }
+                    console.log(`   Matches: ${result.matches.length}`);
+                    console.log('');
+                    for (const match of result.matches.slice(0, 5)) {
+                        const snippet = getMatchSnippet(match.line_content, match.match_start, match.match_end, 80);
+                        console.log(`   Line ${match.line_number}: ${snippet}`);
+                    }
+                    if (result.matches.length > 5) {
+                        console.log(`   ... and ${result.matches.length - 5} more matches`);
+                    }
+                    console.log('');
+                }
+                return;
+            }
+            // Semantic/keyword/hybrid search
+            const queryVector = await generateEmbedding(query);
+            const results = await searchSources(dbPath, queryVector, {
+                limit: parseInt(options.limit),
+                project: options.project,
+                mode: searchMode,
+                queryText: query,
+            });
+            if (results.length === 0) {
+                console.log('No results found.');
+                return;
+            }
+            for (const result of results) {
+                console.log(`━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━`);
+                console.log(`📄 ${result.title}`);
+                console.log(`   Type: ${result.source_type} | ${result.content_type}`);
+                console.log(`   Projects: ${result.projects.join(', ') || '(none)'}`);
+                // Show score and ranks for hybrid mode
+                if (searchMode === 'hybrid' && (result.semantic_rank || result.keyword_rank)) {
+                    const semRank = result.semantic_rank ? `sem=#${result.semantic_rank}` : '';
+                    const kwRank = result.keyword_rank ? `kw=#${result.keyword_rank}` : '';
+                    console.log(`   Score: ${(result.score * 100).toFixed(1)}% [${[semRank, kwRank].filter(Boolean).join(' ')}]`);
+                }
+                else {
+                    console.log(`   Score: ${(result.score * 100).toFixed(1)}%`);
+                }
+                console.log(`\n   ${result.summary}\n`);
+                if (result.quotes.length > 0) {
+                    console.log(`   Key Quotes:`);
+                    for (const quote of result.quotes.slice(0, 3)) {
+                        const speaker = quote.speaker === 'user' ? '[You]' : '[Participant]';
+                        console.log(`   • ${speaker} "${quote.text.substring(0, 100)}..."`);
+                    }
+                }
+                console.log('');
+            }
+        }
+        catch (error) {
+            console.error(`Error: ${error instanceof Error ? error.message : error}`);
+            process.exit(1);
+        }
+    });
+}

package/dist/cli/commands/skills.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Skills Command
+ *
+ * Install Lore agent instruction files into the correct locations
+ * for each supported agent platform, using native plugin/extension formats.
+ *
+ * Each platform gets:
+ * 1. MCP server configuration (so Lore auto-starts)
+ * 2. Instruction/skill files (so the agent knows how to use Lore)
+ *
+ * lore skills list                    — show available skills
+ * lore skills install claude-code     — install Claude Code plugin (MCP + skill)
+ * lore skills install gemini          — install Gemini CLI extension (MCP + GEMINI.md)
+ * lore skills install codex           — install Codex CLI skill (MCP + SKILL.md)
+ * lore skills install openclaw        — install OpenClaw skill (SKILL.md)
+ * lore skills install generic         — print generic instructions to stdout
+ */
+import type { Command } from 'commander';
+export declare function registerSkillsCommand(program: Command): void;
+/**
+ * Interactive skill installation — used by the setup wizard.
+ * Returns a summary of what was installed.
+ */
+export declare function interactiveSkillInstall(): Promise<string[]>;