@getlore/cli 0.2.0

package/dist/cli/commands/daemon.js

@@ -0,0 +1,244 @@
+/**
+ * Daemon Command
+ *
+ * Run lore watch as a background daemon with logging and status tracking.
+ */
+import { spawn } from 'child_process';
+import { existsSync, readFileSync, writeFileSync, unlinkSync } from 'fs';
+import { mkdir } from 'fs/promises';
+import path from 'path';
+import os from 'os';
+// Config directory for daemon files
+const CONFIG_DIR = path.join(os.homedir(), '.config', 'lore');
+const PID_FILE = path.join(CONFIG_DIR, 'daemon.pid');
+const STATUS_FILE = path.join(CONFIG_DIR, 'daemon.status.json');
+const LOG_FILE = path.join(CONFIG_DIR, 'daemon.log');
+async function ensureConfigDir() {
+    await mkdir(CONFIG_DIR, { recursive: true });
+}
+function getPid() {
+    if (!existsSync(PID_FILE))
+        return null;
+    try {
+        const pid = parseInt(readFileSync(PID_FILE, 'utf-8').trim(), 10);
+        // Check if process is actually running
+        try {
+            process.kill(pid, 0); // Signal 0 just checks if process exists
+            return pid;
+        }
+        catch {
+            // Process not running, clean up stale PID file
+            unlinkSync(PID_FILE);
+            return null;
+        }
+    }
+    catch {
+        return null;
+    }
+}
+function getStatus() {
+    if (!existsSync(STATUS_FILE))
+        return null;
+    try {
+        return JSON.parse(readFileSync(STATUS_FILE, 'utf-8'));
+    }
+    catch {
+        return null;
+    }
+}
+export function registerDaemonCommand(program, defaultDataDir) {
+    const daemonCmd = program
+        .command('daemon')
+        .description('Manage the lore background sync daemon');
+    daemonCmd
+        .command('start')
+        .description('Start the daemon in background')
+        .option('-d, --data-dir <dir>', 'Data directory', defaultDataDir)
+        .action(async (options) => {
+        await ensureConfigDir();
+        const existingPid = getPid();
+        if (existingPid) {
+            console.log(`Daemon already running (PID: ${existingPid})`);
+            console.log(`Use "lore daemon status" to check status`);
+            console.log(`Use "lore daemon stop" to stop it`);
+            return;
+        }
+        // Find the daemon runner script path
+        const scriptPath = path.join(path.dirname(process.argv[1]), 'daemon-runner.js');
+        // Spawn the daemon process
+        const child = spawn('node', [scriptPath, options.dataDir], {
+            detached: true,
+            stdio: 'ignore',
+            env: { ...process.env, LORE_DAEMON_MODE: 'true' },
+        });
+        child.unref();
+        // Write PID file
+        writeFileSync(PID_FILE, String(child.pid));
+        // Write initial status
+        const status = {
+            pid: child.pid,
+            started_at: new Date().toISOString(),
+        };
+        writeFileSync(STATUS_FILE, JSON.stringify(status, null, 2));
+        console.log(`Daemon started (PID: ${child.pid})`);
+        console.log(`Log file: ${LOG_FILE}`);
+        console.log(`Use "lore daemon logs" to view activity`);
+    });
+    daemonCmd
+        .command('stop')
+        .description('Stop the daemon')
+        .action(async () => {
+        const pid = getPid();
+        if (!pid) {
+            console.log('Daemon is not running');
+            return;
+        }
+        try {
+            process.kill(pid, 'SIGTERM');
+            console.log(`Daemon stopped (PID: ${pid})`);
+            // Clean up files
+            if (existsSync(PID_FILE))
+                unlinkSync(PID_FILE);
+        }
+        catch (error) {
+            console.error(`Failed to stop daemon: ${error}`);
+        }
+    });
+    daemonCmd
+        .command('restart')
+        .description('Restart the daemon')
+        .option('-d, --data-dir <dir>', 'Data directory', defaultDataDir)
+        .action(async (options) => {
+        const pid = getPid();
+        if (pid) {
+            try {
+                process.kill(pid, 'SIGTERM');
+                console.log(`Stopped existing daemon (PID: ${pid})`);
+                if (existsSync(PID_FILE))
+                    unlinkSync(PID_FILE);
+                // Wait a moment for process to exit
+                await new Promise(resolve => setTimeout(resolve, 500));
+            }
+            catch {
+                // Process might already be dead
+            }
+        }
+        // Start new daemon
+        await ensureConfigDir();
+        const scriptPath = path.join(path.dirname(process.argv[1]), 'daemon-runner.js');
+        const child = spawn('node', [scriptPath, options.dataDir], {
+            detached: true,
+            stdio: 'ignore',
+            env: { ...process.env, LORE_DAEMON_MODE: 'true' },
+        });
+        child.unref();
+        writeFileSync(PID_FILE, String(child.pid));
+        const status = {
+            pid: child.pid,
+            started_at: new Date().toISOString(),
+        };
+        writeFileSync(STATUS_FILE, JSON.stringify(status, null, 2));
+        console.log(`Daemon restarted (PID: ${child.pid})`);
+    });
+    daemonCmd
+        .command('status')
+        .description('Check daemon status')
+        .action(async () => {
+        const pid = getPid();
+        const status = getStatus();
+        console.log('');
+        console.log('Lore Daemon Status');
+        console.log('==================');
+        if (!pid) {
+            console.log('Status: NOT RUNNING');
+            console.log('');
+            console.log('Start with: lore daemon start');
+            return;
+        }
+        console.log(`Status: RUNNING (PID: ${pid})`);
+        if (status) {
+            const started = new Date(status.started_at);
+            const uptime = formatUptime(Date.now() - started.getTime());
+            console.log(`Uptime: ${uptime}`);
+            if (status.last_sync) {
+                const lastSync = new Date(status.last_sync);
+                const ago = formatAgo(Date.now() - lastSync.getTime());
+                console.log(`Last sync: ${ago}`);
+                if (status.last_sync_result) {
+                    const r = status.last_sync_result;
+                    console.log(`  Files scanned: ${r.files_scanned}`);
+                    console.log(`  Files processed: ${r.files_processed}`);
+                    if (r.errors > 0) {
+                        console.log(`  Errors: ${r.errors}`);
+                    }
+                }
+            }
+            else {
+                console.log('Last sync: (not yet synced)');
+            }
+        }
+        console.log('');
+        console.log(`Log file: ${LOG_FILE}`);
+        console.log('View logs: lore daemon logs');
+    });
+    daemonCmd
+        .command('logs')
+        .description('View daemon logs')
+        .option('-f, --follow', 'Follow log output (like tail -f)')
+        .option('-n, --lines <n>', 'Number of lines to show', '50')
+        .action(async (options) => {
+        if (!existsSync(LOG_FILE)) {
+            console.log('No log file found. Daemon may not have run yet.');
+            console.log(`Expected: ${LOG_FILE}`);
+            return;
+        }
+        if (options.follow) {
+            // Use tail -f for following
+            const tail = spawn('tail', ['-f', LOG_FILE], {
+                stdio: 'inherit',
+            });
+            process.on('SIGINT', () => {
+                tail.kill();
+                process.exit(0);
+            });
+            await new Promise(() => { }); // Wait forever
+        }
+        else {
+            // Show last N lines
+            const content = readFileSync(LOG_FILE, 'utf-8');
+            const lines = content.trim().split('\n');
+            const n = parseInt(options.lines, 10);
+            const lastLines = lines.slice(-n);
+            console.log(`Last ${Math.min(n, lastLines.length)} log entries:\n`);
+            console.log(lastLines.join('\n'));
+        }
+    });
+}
+function formatUptime(ms) {
+    const seconds = Math.floor(ms / 1000);
+    const minutes = Math.floor(seconds / 60);
+    const hours = Math.floor(minutes / 60);
+    const days = Math.floor(hours / 24);
+    if (days > 0)
+        return `${days}d ${hours % 24}h`;
+    if (hours > 0)
+        return `${hours}h ${minutes % 60}m`;
+    if (minutes > 0)
+        return `${minutes}m ${seconds % 60}s`;
+    return `${seconds}s`;
+}
+function formatAgo(ms) {
+    const seconds = Math.floor(ms / 1000);
+    if (seconds < 60)
+        return 'just now';
+    const minutes = Math.floor(seconds / 60);
+    if (minutes < 60)
+        return `${minutes}m ago`;
+    const hours = Math.floor(minutes / 60);
+    if (hours < 24)
+        return `${hours}h ago`;
+    const days = Math.floor(hours / 24);
+    return `${days}d ago`;
+}
+// Export paths for use by daemon runner
+export { CONFIG_DIR, PID_FILE, STATUS_FILE, LOG_FILE };

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

@@ -0,0 +1,7 @@
+/**
+ * Documents CLI Commands
+ *
+ * CRUD operations for documents: list, get, create, delete
+ */
+import type { Command } from 'commander';
+export declare function registerDocsCommand(program: Command, defaultDataDir: string): void;

package/dist/cli/commands/docs.js

@@ -0,0 +1,188 @@
+/**
+ * Documents CLI Commands
+ *
+ * CRUD operations for documents: list, get, create, delete
+ */
+import path from 'path';
+import { getSourceById } from '../../core/vector-store.js';
+export function registerDocsCommand(program, defaultDataDir) {
+    const docsCmd = program
+        .command('docs')
+        .description('Document operations (CRUD)');
+    // List documents
+    docsCmd
+        .command('list')
+        .description('List all documents')
+        .option('-p, --project <project>', 'Filter by project')
+        .option('-t, --type <type>', 'Filter by source type')
+        .option('-l, --limit <limit>', 'Max results', '20')
+        .option('-d, --data-dir <dir>', 'Data directory', defaultDataDir)
+        .action(async (options) => {
+        const { handleListSources } = await import('../../mcp/handlers/list-sources.js');
+        const dataDir = options.dataDir;
+        const dbPath = path.join(dataDir, 'lore.lance');
+        const result = await handleListSources(dbPath, {
+            project: options.project,
+            source_type: options.type,
+            limit: parseInt(options.limit),
+        });
+        console.log(`\nDocuments (${result.total}):`);
+        console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
+        if (result.sources.length === 0) {
+            console.log('No documents found.');
+            return;
+        }
+        for (const source of result.sources) {
+            const date = new Date(source.created_at).toLocaleDateString();
+            console.log(`\n📄 ${source.title}`);
+            console.log(`   ID: ${source.id}`);
+            console.log(`   Type: ${source.source_type} | ${source.content_type}`);
+            console.log(`   Projects: ${source.projects.join(', ') || '(none)'}`);
+            console.log(`   Date: ${date}`);
+        }
+        console.log('');
+    });
+    // Get document
+    docsCmd
+        .command('get')
+        .description('Get full details of a document')
+        .argument('<id>', 'Document ID')
+        .option('-c, --content', 'Include full content')
+        .option('-d, --data-dir <dir>', 'Data directory', defaultDataDir)
+        .action(async (docId, options) => {
+        const { handleGetSource } = await import('../../mcp/handlers/get-source.js');
+        const dataDir = options.dataDir;
+        const dbPath = path.join(dataDir, 'lore.lance');
+        const result = await handleGetSource(dbPath, dataDir, {
+            source_id: docId,
+            include_content: options.content,
+        });
+        if (result.error) {
+            console.error(`Error: ${result.error}`);
+            process.exit(1);
+        }
+        console.log(`\n📄 ${result.title}`);
+        console.log(`━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━`);
+        console.log(`ID: ${result.id}`);
+        console.log(`Type: ${result.source_type} | ${result.content_type}`);
+        console.log(`Projects: ${result.projects?.join(', ') || '(none)'}`);
+        console.log(`Tags: ${result.tags?.join(', ') || '(none)'}`);
+        console.log(`Created: ${result.created_at}`);
+        console.log(`\nSummary:\n${result.summary}`);
+        const themes = result.themes;
+        if (themes && themes.length > 0) {
+            console.log(`\nThemes:`);
+            for (const theme of themes) {
+                console.log(`  • ${theme.name}`);
+            }
+        }
+        const quotes = result.quotes;
+        if (quotes && quotes.length > 0) {
+            console.log(`\nQuotes (${quotes.length}):`);
+            for (const quote of quotes.slice(0, 5)) {
+                const speaker = quote.speaker === 'user' ? '[You]' : '[Participant]';
+                console.log(`  ${speaker} "${quote.text.substring(0, 100)}${quote.text.length > 100 ? '...' : ''}"`);
+            }
+            if (quotes.length > 5) {
+                console.log(`  ... and ${quotes.length - 5} more`);
+            }
+        }
+        if (result.full_content) {
+            console.log(`\n${'─'.repeat(60)}`);
+            console.log(`Full Content:\n`);
+            console.log(result.full_content);
+        }
+        console.log('');
+    });
+    // Create (save a note/insight)
+    docsCmd
+        .command('create')
+        .description('Create a note or insight')
+        .argument('<content>', 'Content to save')
+        .requiredOption('-p, --project <project>', 'Project this belongs to')
+        .option('-t, --type <type>', 'Type: insight, decision, requirement, note', 'note')
+        .option('--context <context>', 'Source context (e.g., "from interview with Sarah")')
+        .option('--tags <tags>', 'Comma-separated tags')
+        .option('-d, --data-dir <dir>', 'Data directory', defaultDataDir)
+        .option('--no-push', 'Skip git push')
+        .action(async (content, options) => {
+        const { handleRetain } = await import('../../mcp/handlers/retain.js');
+        const dataDir = options.dataDir;
+        const dbPath = path.join(dataDir, 'lore.lance');
+        const validTypes = ['insight', 'decision', 'requirement', 'note'];
+        if (!validTypes.includes(options.type)) {
+            console.error(`Invalid type: ${options.type}. Must be one of: ${validTypes.join(', ')}`);
+            process.exit(1);
+        }
+        const result = await handleRetain(dbPath, dataDir, {
+            content,
+            project: options.project,
+            type: options.type,
+            source_context: options.context,
+            tags: options.tags?.split(',').map((t) => t.trim()),
+        }, { autoPush: options.push !== false });
+        if (result.success) {
+            console.log(`\n✓ ${result.message}`);
+            console.log(`  ID: ${result.id}`);
+            console.log(`  Indexed: ${result.indexed ? 'yes' : 'no'}`);
+            console.log(`  Synced: ${result.synced ? 'yes' : 'no'}`);
+        }
+        else {
+            console.error(`\nFailed to create: ${result.message}`);
+            process.exit(1);
+        }
+    });
+    // Delete document
+    docsCmd
+        .command('delete')
+        .description('Delete a document')
+        .argument('<id>', 'Document ID')
+        .option('-d, --data-dir <dir>', 'Data directory', defaultDataDir)
+        .option('--force', 'Skip confirmation')
+        .action(async (docId, options) => {
+        const dataDir = options.dataDir;
+        const dbPath = path.join(dataDir, 'lore.lance');
+        // Get document info first
+        const source = await getSourceById(dbPath, docId);
+        if (!source) {
+            console.error(`Document not found: ${docId}`);
+            process.exit(1);
+        }
+        if (!options.force) {
+            const readline = await import('readline');
+            const rl = readline.createInterface({
+                input: process.stdin,
+                output: process.stdout,
+            });
+            const answer = await new Promise((resolve) => {
+                rl.question(`Delete "${source.title}"? (y/N) `, resolve);
+            });
+            rl.close();
+            if (answer.toLowerCase() !== 'y') {
+                console.log('Cancelled.');
+                return;
+            }
+        }
+        // Delete from vector store
+        const { deleteSource } = await import('../../core/vector-store.js');
+        const { sourcePath: originalPath } = await deleteSource(dbPath, docId);
+        // Delete from disk (lore-data copy)
+        const { rm } = await import('fs/promises');
+        const loreSourcePath = path.join(dataDir, 'sources', docId);
+        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) {
+            const { deleteFileAndCommit } = await import('../../core/git.js');
+            await deleteFileAndCommit(originalPath, `Delete: ${source.title.slice(0, 50)}`);
+        }
+        // Git commit the lore-data changes
+        const { gitCommitAndPush } = await import('../../core/git.js');
+        await gitCommitAndPush(dataDir, `Delete source: ${source.title.slice(0, 50)}`);
+        console.log(`\n✓ Deleted: ${source.title}`);
+    });
+}

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

@@ -0,0 +1,7 @@
+/**
+ * Extension Management Commands
+ *
+ * lore extension install|list|remove
+ */
+import type { Command } from 'commander';
+export declare function registerExtensionCommands(program: Command, defaultDataDir?: string): Command;

package/dist/cli/commands/extensions.js

@@ -0,0 +1,204 @@
+/**
+ * Extension Management Commands
+ *
+ * lore extension install|list|remove
+ */
+import path from 'path';
+import os from 'os';
+import { readFile, stat } from 'fs/promises';
+import { promisify } from 'util';
+import { exec, spawn } from 'child_process';
+import { addExtensionToConfig, removeExtensionFromConfig, loadExtensionConfig, ensureExtensionsDir, getExtensionsDir, } from '../../extensions/config.js';
+const execAsync = promisify(exec);
+async function readInstalledVersion(extensionsDir, packageName) {
+    try {
+        const pkgPath = path.join(extensionsDir, 'node_modules', packageName, 'package.json');
+        const content = await readFile(pkgPath, 'utf-8');
+        const parsed = JSON.parse(content);
+        return parsed.version;
+    }
+    catch {
+        return undefined;
+    }
+}
+function resolveExtensionPath(inputPath) {
+    if (inputPath.startsWith('~')) {
+        return path.resolve(path.join(os.homedir(), inputPath.slice(1)));
+    }
+    return path.resolve(inputPath);
+}
+export function registerExtensionCommands(program, defaultDataDir) {
+    const extension = program
+        .command('extension')
+        .description('Manage Lore extensions');
+    extension
+        .command('list')
+        .description('List installed extensions')
+        .action(async () => {
+        const config = await loadExtensionConfig();
+        if (config.extensions.length === 0) {
+            console.log('No extensions installed.');
+            return;
+        }
+        console.log('Installed extensions:');
+        for (const ext of config.extensions) {
+            const status = ext.enabled === false ? 'disabled' : 'enabled';
+            const version = ext.version ? `@${ext.version}` : '';
+            console.log(`  - ${ext.name}${version} (${status})`);
+        }
+    });
+    extension
+        .command('install')
+        .description('Install an extension from npm')
+        .argument('<package>', 'npm package name')
+        .action(async (packageName) => {
+        const extensionsDir = getExtensionsDir();
+        await ensureExtensionsDir();
+        console.log(`Installing ${packageName}...`);
+        await execAsync(`npm install ${packageName}`, { cwd: extensionsDir });
+        const version = await readInstalledVersion(extensionsDir, packageName);
+        await addExtensionToConfig(packageName, version);
+        console.log(`✓ Installed ${packageName}${version ? `@${version}` : ''}`);
+    });
+    extension
+        .command('dev')
+        .description('Link a local extension for development')
+        .argument('<path>', 'local path to extension')
+        .option('--serve', 'start lore serve --watch after install')
+        .action(async (inputPath, options) => {
+        const extensionsDir = getExtensionsDir();
+        await ensureExtensionsDir();
+        const resolvedPath = resolveExtensionPath(inputPath);
+        try {
+            await stat(resolvedPath);
+        }
+        catch {
+            console.error(`Path does not exist: ${inputPath}`);
+            process.exit(1);
+        }
+        let packageName;
+        let packageVersion;
+        try {
+            const pkgPath = path.join(resolvedPath, 'package.json');
+            const content = await readFile(pkgPath, 'utf-8');
+            const parsed = JSON.parse(content);
+            packageName = parsed.name;
+            packageVersion = parsed.version;
+        }
+        catch {
+            console.error(`No package.json found in: ${inputPath}`);
+            process.exit(1);
+        }
+        if (!packageName) {
+            console.error(`package.json is missing a name in: ${inputPath}`);
+            process.exit(1);
+        }
+        console.log(`Installing from ${inputPath}...`);
+        await execAsync(`npm install ${resolvedPath}`, { cwd: extensionsDir });
+        await addExtensionToConfig(packageName, packageVersion);
+        console.log(`✓ Linked ${packageName}${packageVersion ? `@${packageVersion}` : ''}`);
+        if (options.serve) {
+            console.log('Starting lore serve --watch...');
+            const child = spawn('lore serve --watch', { cwd: process.cwd(), stdio: 'inherit', shell: true });
+            await new Promise((resolve, reject) => {
+                child.on('exit', code => {
+                    if (code === 0) {
+                        resolve();
+                    }
+                    else {
+                        reject(new Error(`lore serve --watch exited with code ${code ?? 'unknown'}`));
+                    }
+                });
+                child.on('error', reject);
+            });
+            return;
+        }
+        console.log('\nTo test: lore serve --watch');
+    });
+    extension
+        .command('remove')
+        .description('Remove an installed extension')
+        .argument('<package>', 'npm package name')
+        .action(async (packageName) => {
+        const extensionsDir = getExtensionsDir();
+        await ensureExtensionsDir();
+        console.log(`Removing ${packageName}...`);
+        await execAsync(`npm remove ${packageName}`, { cwd: extensionsDir });
+        await removeExtensionFromConfig(packageName);
+        console.log(`✓ Removed ${packageName}`);
+    });
+    extension
+        .command('update')
+        .description('Update an extension to the latest version')
+        .argument('[package]', 'npm package name (or update all if omitted)')
+        .action(async (packageName) => {
+        const extensionsDir = getExtensionsDir();
+        await ensureExtensionsDir();
+        const config = await loadExtensionConfig();
+        if (packageName) {
+            // Update single extension
+            const ext = config.extensions.find(e => e.name === packageName);
+            if (!ext) {
+                console.error(`Extension ${packageName} is not installed.`);
+                process.exit(1);
+            }
+            console.log(`Updating ${packageName}...`);
+            await execAsync(`npm update ${packageName}`, { cwd: extensionsDir });
+            const newVersion = await readInstalledVersion(extensionsDir, packageName);
+            await addExtensionToConfig(packageName, newVersion);
+            console.log(`✓ Updated ${packageName}${newVersion ? ` to ${newVersion}` : ''}`);
+        }
+        else {
+            // Update all extensions
+            if (config.extensions.length === 0) {
+                console.log('No extensions installed.');
+                return;
+            }
+            console.log('Updating all extensions...');
+            for (const ext of config.extensions) {
+                console.log(`  Updating ${ext.name}...`);
+                await execAsync(`npm update ${ext.name}`, { cwd: extensionsDir });
+                const newVersion = await readInstalledVersion(extensionsDir, ext.name);
+                await addExtensionToConfig(ext.name, newVersion);
+            }
+            console.log('✓ All extensions updated');
+        }
+    });
+    extension
+        .command('enable')
+        .description('Enable a disabled extension')
+        .argument('<package>', 'npm package name')
+        .action(async (packageName) => {
+        const config = await loadExtensionConfig();
+        const ext = config.extensions.find(e => e.name === packageName);
+        if (!ext) {
+            console.error(`Extension ${packageName} is not installed.`);
+            process.exit(1);
+        }
+        if (ext.enabled !== false) {
+            console.log(`Extension ${packageName} is already enabled.`);
+            return;
+        }
+        await addExtensionToConfig(packageName, ext.version, true);
+        console.log(`✓ Enabled ${packageName}`);
+    });
+    extension
+        .command('disable')
+        .description('Disable an extension without removing it')
+        .argument('<package>', 'npm package name')
+        .action(async (packageName) => {
+        const config = await loadExtensionConfig();
+        const ext = config.extensions.find(e => e.name === packageName);
+        if (!ext) {
+            console.error(`Extension ${packageName} is not installed.`);
+            process.exit(1);
+        }
+        if (ext.enabled === false) {
+            console.log(`Extension ${packageName} is already disabled.`);
+            return;
+        }
+        await addExtensionToConfig(packageName, ext.version, false);
+        console.log(`✓ Disabled ${packageName}`);
+    });
+    return extension;
+}

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

@@ -0,0 +1,7 @@
+/**
+ * Miscellaneous CLI Commands
+ *
+ * browse, research, init, serve
+ */
+import type { Command } from 'commander';
+export declare function registerMiscCommands(program: Command, defaultDataDir: string): void;