@getlore/cli 0.3.0 → 0.5.0

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

@@ -0,0 +1,8 @@
+/**
+ * Ingest Command
+ *
+ * Push content directly into Lore from the CLI.
+ * Accepts inline text, a file path, or piped stdin.
+ */
+import type { Command } from 'commander';
+export declare function registerIngestCommand(program: Command, defaultDataDir: string): void;

package/dist/cli/commands/ingest.js

@@ -0,0 +1,104 @@
+/**
+ * Ingest Command
+ *
+ * Push content directly into Lore from the CLI.
+ * Accepts inline text, a file path, or piped stdin.
+ */
+import { readFileSync, existsSync } from 'fs';
+import path from 'path';
+export function registerIngestCommand(program, defaultDataDir) {
+    program
+        .command('ingest')
+        .description('Ingest content into the knowledge base')
+        .argument('[content]', 'Content to ingest (or use --file / stdin)')
+        .option('-f, --file <path>', 'Read content from a file')
+        .option('-t, --title <title>', 'Document title')
+        .option('-p, --project <project>', 'Project name', 'default')
+        .option('--type <type>', 'Source type (e.g. meeting, notes, article)')
+        .option('--url <url>', 'Source URL for citation linking')
+        .option('--name <name>', 'Human-readable source name')
+        .option('--tags <tags>', 'Comma-separated tags')
+        .option('-d, --data-dir <dir>', 'Data directory', defaultDataDir)
+        .action(async (contentArg, options) => {
+        const { handleIngest } = await import('../../mcp/handlers/ingest.js');
+        const dataDir = options.dataDir;
+        const dbPath = path.join(dataDir, 'lore.lance');
+        // Resolve content from argument, file, or stdin
+        let content;
+        if (options.file) {
+            const filePath = options.file.replace(/^~/, process.env.HOME || '~');
+            if (!existsSync(filePath)) {
+                console.error(`File not found: ${filePath}`);
+                process.exit(1);
+            }
+            content = readFileSync(filePath, 'utf-8');
+        }
+        else if (contentArg) {
+            content = contentArg;
+        }
+        else if (!process.stdin.isTTY) {
+            // Reading from pipe/stdin
+            content = readFileSync(0, 'utf-8');
+        }
+        else {
+            console.error('No content provided. Use one of:');
+            console.error('  lore ingest "Your content here"');
+            console.error('  lore ingest --file ./notes.md');
+            console.error('  echo "content" | lore ingest');
+            process.exit(1);
+        }
+        content = content.trim();
+        if (!content) {
+            console.error('Content is empty.');
+            process.exit(1);
+        }
+        // Derive title from file name or content
+        let title = options.title;
+        if (!title && options.file) {
+            title = path.basename(options.file, path.extname(options.file));
+        }
+        if (!title) {
+            // Use first line or first 60 chars
+            const firstLine = content.split('\n')[0].replace(/^#+\s*/, '');
+            title = firstLine.length > 60 ? firstLine.slice(0, 57) + '...' : firstLine;
+        }
+        const tags = options.tags ? options.tags.split(',').map((t) => t.trim()) : [];
+        console.log(`\nIngesting: ${title}`);
+        console.log(`Project:   ${options.project}`);
+        if (options.type)
+            console.log(`Type:      ${options.type}`);
+        console.log(`Content:   ${content.length} chars`);
+        console.log('');
+        const result = await handleIngest(dbPath, dataDir, {
+            content,
+            title,
+            project: options.project,
+            source_type: options.type,
+            tags,
+            source_url: options.url,
+            source_name: options.name,
+        }, {
+            hookContext: { mode: 'cli' },
+        });
+        if (result.deduplicated) {
+            console.log('Already exists (identical content). Skipped.');
+            return;
+        }
+        if (result.success) {
+            console.log(`Ingested (ID: ${result.id})`);
+            if (result.indexed) {
+                console.log('Indexed and searchable.');
+            }
+            else {
+                console.log('Saved to disk. Run "lore sync" to index.');
+            }
+            if (result.synced) {
+                console.log('Pushed to git.');
+            }
+        }
+        else {
+            console.error('Ingestion failed.');
+            process.exit(1);
+        }
+    });
+}

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

@@ -19,6 +19,14 @@ export interface DaemonStatus {
     };
 }
 export declare function registerSyncCommand(program: Command, defaultDataDir: string): void;
+/**
+ * Restart the background sync daemon.
+ * Stops the existing daemon (if running), then starts a fresh one.
+ * Returns { pid } on success, null on failure.
+ */
+export declare function restartDaemon(dataDir: string): Promise<{
+    pid: number;
+} | null>;
 /**
  * Start the background sync daemon process.
  * Returns { pid } on success, null on failure.
@@ -28,4 +36,8 @@ export declare function startDaemonProcess(dataDir: string): Promise<{
     pid: number;
     alreadyRunning: boolean;
 } | null>;
+/**
+ * Check if the sync daemon is currently running.
+ */
+export declare function isDaemonRunning(): boolean;
 export { CONFIG_DIR, PID_FILE, STATUS_FILE, LOG_FILE };

package/dist/cli/commands/sync.js

@@ -270,25 +270,7 @@ export function registerSyncCommand(program, defaultDataDir) {
         .description('Restart background sync daemon')
         .option('-d, --data-dir <dir>', 'Data directory', defaultDataDir)
         .action(async (options) => {
-        // Uninstall launchd agent so it doesn't auto-restart during our restart
-        if (isLaunchdInstalled()) {
-            uninstallLaunchdAgent();
-        }
-        const pid = getPid();
-        if (pid) {
-            try {
-                process.kill(pid, 'SIGTERM');
-                console.log(`Stopped existing daemon (PID: ${pid})`);
-                if (existsSync(PID_FILE))
-                    unlinkSync(PID_FILE);
-                await new Promise(resolve => setTimeout(resolve, 500));
-            }
-            catch {
-                // Process might already be dead
-            }
-        }
-        // startDaemonProcess will reinstall launchd with fresh config on macOS
-        const result = await startDaemonProcess(options.dataDir);
+        const result = await restartDaemon(options.dataDir);
         if (!result) {
             console.error('Failed to restart daemon - check logs with: lore sync logs');
             return;
@@ -723,6 +705,34 @@ export function registerSyncCommand(program, defaultDataDir) {
 // ============================================================================
 // Exported helpers
 // ============================================================================
+/**
+ * Restart the background sync daemon.
+ * Stops the existing daemon (if running), then starts a fresh one.
+ * Returns { pid } on success, null on failure.
+ */
+export async function restartDaemon(dataDir) {
+    // Uninstall launchd agent so it doesn't auto-restart during our restart
+    if (isLaunchdInstalled()) {
+        uninstallLaunchdAgent();
+    }
+    const pid = getPid();
+    if (pid) {
+        try {
+            process.kill(pid, 'SIGTERM');
+            if (existsSync(PID_FILE))
+                unlinkSync(PID_FILE);
+            await new Promise(resolve => setTimeout(resolve, 500));
+        }
+        catch {
+            // Process might already be dead
+        }
+    }
+    // startDaemonProcess will reinstall launchd with fresh config on macOS
+    const result = await startDaemonProcess(dataDir);
+    if (!result)
+        return null;
+    return { pid: result.pid };
+}
 /**
  * Start the background sync daemon process.
  * Returns { pid } on success, null on failure.
@@ -764,5 +774,11 @@ export async function startDaemonProcess(dataDir) {
         return null;
     }
 }
+/**
+ * Check if the sync daemon is currently running.
+ */
+export function isDaemonRunning() {
+    return getPid() !== null;
+}
 // Export for daemon-runner and browse
 export { CONFIG_DIR, PID_FILE, STATUS_FILE, LOG_FILE };

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

@@ -0,0 +1,8 @@
+/**
+ * Update Command
+ *
+ * Check for and install updates to @getlore/cli.
+ * Restarts the background daemon after upgrading so it picks up new code.
+ */
+import type { Command } from 'commander';
+export declare function registerUpdateCommand(program: Command, defaultDataDir: string): void;

package/dist/cli/commands/update.js

@@ -0,0 +1,71 @@
+/**
+ * Update Command
+ *
+ * Check for and install updates to @getlore/cli.
+ * Restarts the background daemon after upgrading so it picks up new code.
+ */
+import { spawnSync } from 'child_process';
+import { c } from '../colors.js';
+import { getLoreVersionString } from '../../extensions/registry.js';
+import { restartDaemon, isDaemonRunning } from './sync.js';
+const NPM_PACKAGE = '@getlore/cli';
+function getLatestVersion() {
+    const result = spawnSync('npm', ['view', NPM_PACKAGE, 'version'], {
+        encoding: 'utf-8',
+        timeout: 10_000,
+        stdio: ['ignore', 'pipe', 'pipe'],
+    });
+    if (result.status !== 0 || !result.stdout)
+        return null;
+    return result.stdout.trim();
+}
+export function registerUpdateCommand(program, defaultDataDir) {
+    program
+        .command('update')
+        .description('Check for and install updates')
+        .option('--check', 'Check for updates without installing')
+        .action(async (options) => {
+        const currentVersion = (await getLoreVersionString()) || 'unknown';
+        console.log(`\nCurrent version: ${c.bold(currentVersion)}`);
+        console.log('Checking npm for latest version...');
+        const latestVersion = getLatestVersion();
+        if (!latestVersion) {
+            console.error('Could not check npm registry. Are you online?');
+            process.exit(1);
+        }
+        console.log(`Latest version:  ${c.bold(latestVersion)}`);
+        if (currentVersion === latestVersion) {
+            console.log(c.success('\nAlready up to date!'));
+            return;
+        }
+        console.log(`\nUpdate available: ${c.dim(currentVersion)} → ${c.success(latestVersion)}`);
+        if (options.check) {
+            console.log(`\nRun ${c.bold('lore update')} to install.`);
+            return;
+        }
+        // Install
+        console.log(`\nInstalling ${NPM_PACKAGE}@${latestVersion}...`);
+        const installResult = spawnSync('npm', ['install', '-g', `${NPM_PACKAGE}@latest`], {
+            stdio: 'inherit',
+            timeout: 120_000,
+        });
+        if (installResult.status !== 0) {
+            console.error('\nInstallation failed. You may need to run with sudo:');
+            console.error(`  sudo npm install -g ${NPM_PACKAGE}@latest`);
+            process.exit(1);
+        }
+        console.log(c.success(`\nUpdated to ${latestVersion}!`));
+        // Restart daemon if running
+        if (isDaemonRunning()) {
+            console.log('\nRestarting background daemon...');
+            const result = await restartDaemon(defaultDataDir);
+            if (result) {
+                console.log(c.success(`Daemon restarted (PID: ${result.pid})`));
+            }
+            else {
+                console.log(c.warning('Could not restart daemon. Run: lore sync restart'));
+            }
+        }
+        console.log('');
+    });
+}

package/dist/cli/update-notifier.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Passive Update Notifier
+ *
+ * Checks npm for a newer version of @getlore/cli once every 24 hours.
+ * Prints a subtle notification after command output if an update is available.
+ * Never blocks or throws — all errors are silently swallowed.
+ */
+/**
+ * Check for updates and print a notification if one is available.
+ * Safe to call fire-and-forget — never throws, never blocks meaningfully.
+ */
+export declare function checkForUpdates(): Promise<void>;

package/dist/cli/update-notifier.js

@@ -0,0 +1,95 @@
+/**
+ * Passive Update Notifier
+ *
+ * Checks npm for a newer version of @getlore/cli once every 24 hours.
+ * Prints a subtle notification after command output if an update is available.
+ * Never blocks or throws — all errors are silently swallowed.
+ */
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'fs';
+import { spawnSync } from 'child_process';
+import path from 'path';
+import os from 'os';
+import { colors } from './colors.js';
+import { getLoreVersionString } from '../extensions/registry.js';
+const NPM_PACKAGE = '@getlore/cli';
+const CONFIG_DIR = path.join(os.homedir(), '.config', 'lore');
+const CACHE_FILE = path.join(CONFIG_DIR, 'update-check.json');
+const CHECK_INTERVAL_MS = 24 * 60 * 60 * 1000; // 24 hours
+function readCache() {
+    try {
+        if (!existsSync(CACHE_FILE))
+            return null;
+        return JSON.parse(readFileSync(CACHE_FILE, 'utf-8'));
+    }
+    catch {
+        return null;
+    }
+}
+function writeCache(cache) {
+    try {
+        if (!existsSync(CONFIG_DIR))
+            mkdirSync(CONFIG_DIR, { recursive: true });
+        writeFileSync(CACHE_FILE, JSON.stringify(cache, null, 2));
+    }
+    catch {
+        // Silently ignore
+    }
+}
+/**
+ * Check for updates and print a notification if one is available.
+ * Safe to call fire-and-forget — never throws, never blocks meaningfully.
+ */
+export async function checkForUpdates() {
+    // Don't notify in non-interactive contexts
+    if (!process.stdout.isTTY)
+        return;
+    const cache = readCache();
+    const now = Date.now();
+    let latestVersion;
+    if (cache && (now - cache.last_check) < CHECK_INTERVAL_MS) {
+        // Use cached value
+        latestVersion = cache.latest_version;
+    }
+    else {
+        // Fetch from npm with short timeout
+        const result = spawnSync('npm', ['view', NPM_PACKAGE, 'version'], {
+            encoding: 'utf-8',
+            timeout: 5_000,
+            stdio: ['ignore', 'pipe', 'pipe'],
+        });
+        if (result.status !== 0 || !result.stdout)
+            return;
+        latestVersion = result.stdout.trim();
+        writeCache({
+            last_check: now,
+            latest_version: latestVersion,
+            last_notified_version: cache?.last_notified_version,
+        });
+    }
+    const currentVersion = await getLoreVersionString();
+    if (!currentVersion || currentVersion === latestVersion)
+        return;
+    // Don't re-notify for the same version
+    if (cache?.last_notified_version === latestVersion)
+        return;
+    // Print notification
+    const border = `${colors.dim}╭────────────────────────────────────────╮${colors.reset}`;
+    const bottom = `${colors.dim}╰────────────────────────────────────────╯${colors.reset}`;
+    const pad = (s, width) => {
+        // Strip ANSI for length calculation
+        const stripped = s.replace(/\x1b\[[0-9;]*m/g, '');
+        const padding = Math.max(0, width - stripped.length);
+        return s + ' '.repeat(padding);
+    };
+    console.log('');
+    console.log(border);
+    console.log(`${colors.dim}│${colors.reset} ${pad(`Update available: ${colors.dim}${currentVersion}${colors.reset} → ${colors.green}${latestVersion}${colors.reset}`, 39)}${colors.dim}│${colors.reset}`);
+    console.log(`${colors.dim}│${colors.reset} ${pad(`Run ${colors.bold}lore update${colors.reset} to upgrade`, 39)}${colors.dim}│${colors.reset}`);
+    console.log(bottom);
+    // Mark as notified
+    writeCache({
+        last_check: cache?.last_check || now,
+        latest_version: latestVersion,
+        last_notified_version: latestVersion,
+    });
+}

package/dist/index.js

@@ -29,6 +29,8 @@ import { registerPendingCommand } from './cli/commands/pending.js';
 import { registerAskCommand } from './cli/commands/ask.js';
 import { registerAuthCommands } from './cli/commands/auth.js';
 import { registerSkillsCommand } from './cli/commands/skills.js';
+import { registerUpdateCommand } from './cli/commands/update.js';
+import { registerIngestCommand } from './cli/commands/ingest.js';
 import { getExtensionRegistry, getLoreVersionString } from './extensions/registry.js';
 import { bridgeConfigToEnv } from './core/config.js';
 import { expandPath } from './sync/config.js';
@@ -76,6 +78,8 @@ registerMiscCommands(program, DEFAULT_DATA_DIR);
 registerAskCommand(program, DEFAULT_DATA_DIR);
 registerAuthCommands(program);
 registerSkillsCommand(program);
+registerUpdateCommand(program, DEFAULT_DATA_DIR);
+registerIngestCommand(program, DEFAULT_DATA_DIR);
 // Extension system — hidden from top-level help for now
 const extensionCmd = registerExtensionCommands(program);
 extensionCmd._hidden = true;
@@ -101,5 +105,11 @@ process.on('unhandledRejection', (reason) => {
     console.error(`\nError: ${message}`);
     process.exit(1);
 });
-// Parse and run
-program.parse();
+// Parse and run, then show update notification after command output
+await program.parseAsync();
+// Passive update notification (non-blocking, silent on errors)
+try {
+    const { checkForUpdates } = await import('./cli/update-notifier.js');
+    await checkForUpdates();
+}
+catch { }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@getlore/cli",
-  "version": "0.3.0",
+  "version": "0.5.0",
   "description": "Research knowledge repository with semantic search, citations, and project lineage tracking",
   "type": "module",
   "main": "dist/index.js",