@getlore/cli 0.2.0 → 0.4.0

package/dist/cli/commands/auth.js

@@ -37,6 +37,8 @@ export function registerAuthCommands(program) {
         .command('login')
         .description('Sign in with email (OTP)')
         .option('-e, --email <email>', 'Email address')
+        .option('--code <code>', 'OTP code (skip interactive prompt — use after --send-only)')
+        .option('--send-only', 'Send OTP and exit without waiting for code')
         .action(async (options) => {
         const { sendOTP, verifyOTP, sessionFromMagicLink, waitForMagicLinkCallback, isAuthenticated } = await import('../../core/auth.js');
         // Check if already logged in
@@ -52,25 +54,37 @@ export function registerAuthCommands(program) {
             console.error(c.error('Email is required'));
             process.exit(1);
         }
-        // Start the localhost callback server before sending the OTP
-        // so it's ready when the user clicks the magic link
-        const callback = waitForMagicLinkCallback({
-            onListening: () => {
-                // Server is ready — now send the OTP
-            },
-        });
+        // Non-interactive: --code provided → verify directly (OTP must have been sent already)
+        if (options.code) {
+            const { session, error } = await verifyOTP(email, options.code);
+            if (error || !session) {
+                console.error(c.error(`Verification failed: ${error || 'Unknown error'}`));
+                process.exit(1);
+            }
+            console.log(c.success(`Logged in as ${session.user.email}`));
+            return;
+        }
+        // Send OTP
         console.log(c.dim(`Sending code to ${email}...`));
         const { error: sendError } = await sendOTP(email);
         if (sendError) {
-            callback.abort();
             console.error(c.error(`Failed to send code: ${sendError}`));
             process.exit(1);
         }
-        console.log(c.success('Check your email!'));
+        console.log(c.success(`OTP sent to ${email}`));
+        // --send-only: exit after sending
+        if (options.sendOnly) {
+            console.log(c.dim('Re-run with --code <code> to complete login.'));
+            return;
+        }
         console.log(c.dim('Click the magic link in the email — it will sign you in automatically.'));
         console.log(c.dim('Or paste a 6-digit code if your email shows one.'));
         console.log('');
         console.log(c.dim('Waiting for magic link click...'));
+        // Start the localhost callback server
+        const callback = waitForMagicLinkCallback({
+            onListening: () => { },
+        });
         // Race: callback server catches the magic link, or user pastes a code/URL
         const readline = await import('readline');
         const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
@@ -158,19 +172,27 @@ export function registerAuthCommands(program) {
     program
         .command('setup')
         .description('Guided setup wizard (config, login, init)')
-        .action(async () => {
+        .option('--openai-key <key>', 'OpenAI API key (skip prompt)')
+        .option('--anthropic-key <key>', 'Anthropic API key (skip prompt)')
+        .option('-e, --email <email>', 'Email address (skip prompt)')
+        .option('--data-dir <dir>', 'Data directory path (skip prompt)')
+        .option('--code <code>', 'OTP code (for non-interactive login)')
+        .option('--skip-login', 'Skip the login step (use if already authenticated)')
+        .action(async (options) => {
         const { saveLoreConfig, getLoreConfigPath } = await import('../../core/config.js');
         const { sendOTP, verifyOTP, sessionFromMagicLink, isAuthenticated, loadAuthSession } = await import('../../core/auth.js');
         const { bridgeConfigToEnv } = await import('../../core/config.js');
+        // Non-interactive mode: skip prompts when all key flags are provided
+        const nonInteractive = !!(options.openaiKey && options.anthropicKey && options.email);
         console.log(`\n${c.title('Lore Setup Wizard')}`);
         console.log(`${c.dim('=')}`.repeat(40) + '\n');
         // ── Step 1: Configuration ───────────────────────────────────────
         console.log(c.bold('Step 1: Configuration\n'));
         const { expandPath } = await import('../../sync/config.js');
         const defaultDataDir = process.env.LORE_DATA_DIR || '~/.lore';
-        const dataDir = await prompt('Data directory', defaultDataDir);
-        const openaiApiKey = await prompt('OpenAI API Key (for embeddings)');
-        const anthropicApiKey = await prompt('Anthropic API Key (for sync & research)');
+        const dataDir = options.dataDir || await prompt('Data directory', defaultDataDir);
+        const openaiApiKey = options.openaiKey || process.env.OPENAI_API_KEY || await prompt('OpenAI API Key (for embeddings)');
+        const anthropicApiKey = options.anthropicKey || process.env.ANTHROPIC_API_KEY || await prompt('Anthropic API Key (for sync & research)');
         await saveLoreConfig({
             ...(dataDir ? { data_dir: expandPath(dataDir) } : {}),
             ...(openaiApiKey ? { openai_api_key: openaiApiKey } : {}),
@@ -181,46 +203,75 @@ export function registerAuthCommands(program) {
         await bridgeConfigToEnv();
         // ── Step 2: Login ──────────────────────────────────────────────────
         console.log(c.bold('Step 2: Login\n'));
-        if (await isAuthenticated()) {
+        if (options.skipLogin) {
+            console.log(c.dim('Skipped (--skip-login)\n'));
+        }
+        else if (await isAuthenticated()) {
             const session = await loadAuthSession();
             console.log(c.success(`Already logged in as ${session?.user.email}\n`));
         }
         else {
-            const email = await prompt('Email');
+            const email = options.email || await prompt('Email');
             if (!email) {
                 console.error(c.error('Email is required'));
                 process.exit(1);
             }
-            console.log(c.dim(`Sending code to ${email}...`));
-            const { error: sendError } = await sendOTP(email);
-            if (sendError) {
-                console.error(c.error(`Failed to send code: ${sendError}`));
-                process.exit(1);
-            }
-            console.log(c.success('Check your email!'));
-            console.log(c.dim('You may receive a 6-digit code or a magic link URL.'));
-            const response = await prompt('Paste the code or the full magic link URL');
-            if (!response) {
-                console.error(c.error('Code or magic link is required'));
-                process.exit(1);
+            if (options.code) {
+                // Non-interactive: --code provided → verify directly (OTP must have been sent already)
+                const result = await verifyOTP(email, options.code);
+                if (result.error || !result.session) {
+                    console.error(c.error(`Verification failed: ${result.error || 'Unknown error'}`));
+                    process.exit(1);
+                }
+                console.log(c.success(`Logged in as ${result.session.user.email}\n`));
             }
-            let session;
-            let verifyError;
-            if (response.startsWith('http')) {
-                const result = await sessionFromMagicLink(response);
-                session = result.session;
-                verifyError = result.error;
+            else if (nonInteractive) {
+                // Non-interactive without --code: send OTP and exit so agent can retrieve code
+                console.log(c.dim(`Sending code to ${email}...`));
+                const { error: sendError } = await sendOTP(email);
+                if (sendError) {
+                    console.error(c.error(`Failed to send code: ${sendError}`));
+                    process.exit(1);
+                }
+                console.log(c.success(`OTP sent to ${email}`));
+                console.log(c.dim('Re-run with --code <code> to complete setup.\n'));
+                console.log(c.dim('Example:'));
+                console.log(c.dim(`  lore setup --openai-key ... --anthropic-key ... --email ${email} --code <code>\n`));
+                return; // Exit — config is saved, agent re-runs with --code
             }
             else {
-                const result = await verifyOTP(email, response);
-                session = result.session;
-                verifyError = result.error;
-            }
-            if (verifyError || !session) {
-                console.error(c.error(`Verification failed: ${verifyError || 'Unknown error'}`));
-                process.exit(1);
+                // Interactive: send OTP and prompt
+                console.log(c.dim(`Sending code to ${email}...`));
+                const { error: sendError } = await sendOTP(email);
+                if (sendError) {
+                    console.error(c.error(`Failed to send code: ${sendError}`));
+                    process.exit(1);
+                }
+                console.log(c.success('Check your email!'));
+                console.log(c.dim('You may receive a 6-digit code or a magic link URL.'));
+                const response = await prompt('Paste the code or the full magic link URL');
+                if (!response) {
+                    console.error(c.error('Code or magic link is required'));
+                    process.exit(1);
+                }
+                let session;
+                let verifyError;
+                if (response.startsWith('http')) {
+                    const result = await sessionFromMagicLink(response);
+                    session = result.session;
+                    verifyError = result.error;
+                }
+                else {
+                    const result = await verifyOTP(email, response);
+                    session = result.session;
+                    verifyError = result.error;
+                }
+                if (verifyError || !session) {
+                    console.error(c.error(`Verification failed: ${verifyError || 'Unknown error'}`));
+                    process.exit(1);
+                }
+                console.log(c.success(`Logged in as ${session.user.email}\n`));
             }
-            console.log(c.success(`Logged in as ${session.user.email}\n`));
         }
         // ── Step 3: Data Repository ────────────────────────────────────────
         console.log(c.bold('Step 3: Data Repository\n'));
@@ -262,7 +313,7 @@ export function registerAuthCommands(program) {
             if (savedUrl) {
                 // Machine B: clone existing repo
                 console.log(c.success(`Found your data repo URL: ${savedUrl}`));
-                const cloneIt = await prompt('Clone it to ' + resolvedDataDir + '? (y/n)', 'y');
+                const cloneIt = nonInteractive ? 'y' : await prompt('Clone it to ' + resolvedDataDir + '? (y/n)', 'y');
                 if (cloneIt.toLowerCase() === 'y') {
                     try {
                         const { execSync } = await import('child_process');
@@ -284,9 +335,9 @@ export function registerAuthCommands(program) {
                 console.log(c.success('Created data repository.\n'));
                 // Try to set up GitHub remote
                 if (await isGhAvailable()) {
-                    const createRepo = await prompt('Create a private GitHub repo for cross-machine sync? (y/n)', 'y');
+                    const createRepo = nonInteractive ? 'y' : await prompt('Create a private GitHub repo for cross-machine sync? (y/n)', 'y');
                     if (createRepo.toLowerCase() === 'y') {
-                        const repoName = await prompt('Repository name', 'lore-data');
+                        const repoName = nonInteractive ? 'lore-data' : await prompt('Repository name', 'lore-data');
                         const url = await createGithubRepo(resolvedDataDir, repoName);
                         if (url) {
                             console.log(c.success(`Created and pushed to ${url}\n`));
@@ -303,7 +354,7 @@ export function registerAuthCommands(program) {
                         }
                     }
                 }
-                else {
+                else if (!nonInteractive) {
                     const remoteUrl = await prompt('Git remote URL for cross-machine sync (or press Enter to skip)');
                     if (remoteUrl) {
                         try {
@@ -344,7 +395,7 @@ export function registerAuthCommands(program) {
             if (savedUrl) {
                 // Found existing repo — add as remote and pull
                 console.log(c.success(`Found your data repo: ${savedUrl}`));
-                const useIt = await prompt('Add as remote and pull? (y/n)', 'y');
+                const useIt = nonInteractive ? 'y' : await prompt('Add as remote and pull? (y/n)', 'y');
                 if (useIt.toLowerCase() === 'y') {
                     try {
                         const { execSync } = await import('child_process');
@@ -359,9 +410,9 @@ export function registerAuthCommands(program) {
                 }
             }
             else if (await isGhAvailable()) {
-                const createRepo = await prompt('Create a private GitHub repo for cross-machine sync? (y/n)', 'y');
+                const createRepo = nonInteractive ? 'y' : await prompt('Create a private GitHub repo for cross-machine sync? (y/n)', 'y');
                 if (createRepo.toLowerCase() === 'y') {
-                    const repoName = await prompt('Repository name', 'lore-data');
+                    const repoName = nonInteractive ? 'lore-data' : await prompt('Repository name', 'lore-data');
                     const url = await createGithubRepo(resolvedDataDir, repoName);
                     if (url) {
                         console.log(c.success(`Created and pushed to ${url}\n`));
@@ -377,7 +428,7 @@ export function registerAuthCommands(program) {
                     }
                 }
             }
-            else {
+            else if (!nonInteractive) {
                 const remoteUrl = await prompt('Git remote URL for cross-machine sync (or press Enter to skip)');
                 if (remoteUrl) {
                     try {
@@ -430,7 +481,7 @@ export function registerAuthCommands(program) {
         }
         // ── Step 5: Background Daemon ──────────────────────────────────────
         console.log(c.bold('Step 5: Background Daemon\n'));
-        const startDaemon = await prompt('Start background sync daemon? (y/n)', 'y');
+        const startDaemon = nonInteractive ? 'y' : await prompt('Start background sync daemon? (y/n)', 'y');
         if (startDaemon.toLowerCase() === 'y') {
             try {
                 const { startDaemonProcess } = await import('./sync.js');
@@ -455,22 +506,28 @@ export function registerAuthCommands(program) {
         }
         // ── Step 6: Agent Skills ──────────────────────────────────────────
         console.log(c.bold('Step 6: Agent Skills\n'));
-        console.log(c.dim('Lore works best when your AI agents know how to use it.'));
-        console.log(c.dim('Install instruction files so agents automatically search and ingest into Lore.\n'));
-        try {
-            const { interactiveSkillInstall } = await import('./skills.js');
-            const installed = await interactiveSkillInstall();
-            if (installed.length > 0) {
-                console.log(c.success(`\nInstalled skills: ${installed.join(', ')}\n`));
+        if (nonInteractive) {
+            console.log(c.dim('Skipped in non-interactive mode.'));
+            console.log(c.dim('Install later with: lore skills install <name>\n'));
+        }
+        else {
+            console.log(c.dim('Lore works best when your AI agents know how to use it.'));
+            console.log(c.dim('Install instruction files so agents automatically search and ingest into Lore.\n'));
+            try {
+                const { interactiveSkillInstall } = await import('./skills.js');
+                const installed = await interactiveSkillInstall();
+                if (installed.length > 0) {
+                    console.log(c.success(`\nInstalled skills: ${installed.join(', ')}\n`));
+                }
+                else {
+                    console.log(c.dim('\nSkipped. You can install later with: lore skills install <name>\n'));
+                }
             }
-            else {
-                console.log(c.dim('\nSkipped. You can install later with: lore skills install <name>\n'));
+            catch (err) {
+                console.log(c.warning(`Could not install skills: ${err instanceof Error ? err.message : err}`));
+                console.log(c.dim('You can install later with: lore skills install <name>\n'));
             }
         }
-        catch (err) {
-            console.log(c.warning(`Could not install skills: ${err instanceof Error ? err.message : err}`));
-            console.log(c.dim('You can install later with: lore skills install <name>\n'));
-        }
         // ── Done ───────────────────────────────────────────────────────────
         console.log(c.title('Setup complete!\n'));
         console.log('Try these commands:');

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,7 @@ 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 { getExtensionRegistry, getLoreVersionString } from './extensions/registry.js';
 import { bridgeConfigToEnv } from './core/config.js';
 import { expandPath } from './sync/config.js';
@@ -76,6 +77,7 @@ registerMiscCommands(program, DEFAULT_DATA_DIR);
 registerAskCommand(program, DEFAULT_DATA_DIR);
 registerAuthCommands(program);
 registerSkillsCommand(program);
+registerUpdateCommand(program, DEFAULT_DATA_DIR);
 // Extension system — hidden from top-level help for now
 const extensionCmd = registerExtensionCommands(program);
 extensionCmd._hidden = true;
@@ -101,5 +103,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.2.0",
+  "version": "0.4.0",
   "description": "Research knowledge repository with semantic search, citations, and project lineage tracking",
   "type": "module",
   "main": "dist/index.js",