@getlore/cli 0.2.0

package/dist/daemon-runner.js

@@ -0,0 +1,246 @@
+#!/usr/bin/env node
+/**
+ * Daemon Runner
+ *
+ * This script runs as a background process, handling file watching and periodic sync.
+ * It writes logs to ~/.config/lore/daemon.log and updates status in daemon.status.json.
+ */
+import path from 'path';
+import os from 'os';
+import { existsSync, appendFileSync, writeFileSync, readFileSync } from 'fs';
+import { mkdir } from 'fs/promises';
+// Config paths
+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');
+// Get data directory from command line arg
+const dataDir = process.argv[2] || process.env.LORE_DATA_DIR || '~/.lore';
+const dbPath = path.join(dataDir, 'lore.lance');
+function log(level, message) {
+    const timestamp = new Date().toISOString().replace('T', ' ').slice(0, 19);
+    const line = `[${timestamp}] ${level.padEnd(5)} ${message}\n`;
+    appendFileSync(LOG_FILE, line);
+}
+function updateStatus(updates) {
+    try {
+        let status = {
+            pid: process.pid,
+            started_at: new Date().toISOString(),
+        };
+        if (existsSync(STATUS_FILE)) {
+            const existing = JSON.parse(readFileSync(STATUS_FILE, 'utf-8'));
+            // Only preserve last_sync info, always use current pid/started_at
+            if (existing.last_sync)
+                status.last_sync = existing.last_sync;
+            if (existing.last_sync_result)
+                status.last_sync_result = existing.last_sync_result;
+        }
+        Object.assign(status, updates);
+        writeFileSync(STATUS_FILE, JSON.stringify(status, null, 2));
+    }
+    catch (error) {
+        log('ERROR', `Failed to update status: ${error}`);
+    }
+}
+async function runSync(gitPull = true) {
+    const { handleSync } = await import('./mcp/handlers/sync.js');
+    const result = await handleSync(dbPath, dataDir, {
+        git_pull: gitPull,
+        git_push: true,
+    }, { hookContext: { mode: 'cli' } });
+    return {
+        files_scanned: result.discovery?.total_files || 0,
+        files_processed: result.processing?.processed || 0,
+        errors: result.processing?.errors || 0,
+        titles: result.processing?.titles || [],
+    };
+}
+async function main() {
+    await mkdir(CONFIG_DIR, { recursive: true });
+    // Bridge config.json → process.env (critical for launchd which has no shell env)
+    const { bridgeConfigToEnv } = await import('./core/config.js');
+    await bridgeConfigToEnv();
+    // Write PID file immediately so parent knows we started
+    writeFileSync(PID_FILE, String(process.pid));
+    // Also initialize status file with correct PID
+    updateStatus({});
+    log('START', `Daemon starting (PID: ${process.pid})`);
+    log('INFO', `Data directory: ${dataDir}`);
+    // Load sync config
+    const { loadSyncConfig, getEnabledSources, expandPath } = await import('./sync/config.js');
+    const { matchesGlob } = await import('./sync/discover.js');
+    const config = await loadSyncConfig();
+    const sources = getEnabledSources(config);
+    if (sources.length === 0) {
+        log('WARN', 'No local sync sources configured');
+        log('INFO', 'Will still sync from remote');
+    }
+    else {
+        for (const source of sources) {
+            log('INFO', `Watching: ${source.name} (${expandPath(source.path)})`);
+        }
+    }
+    // Initial sync
+    log('SYNC', 'Running initial sync...');
+    try {
+        const result = await runSync(true);
+        log('SYNC', `Initial sync complete: ${result.files_scanned} scanned, ${result.files_processed} processed`);
+        for (const title of result.titles) {
+            log('INDEX', title);
+        }
+        updateStatus({
+            last_sync: new Date().toISOString(),
+            last_sync_result: {
+                files_scanned: result.files_scanned,
+                files_processed: result.files_processed,
+                errors: result.errors,
+            },
+        });
+    }
+    catch (error) {
+        log('ERROR', `Initial sync failed: ${error}`);
+    }
+    // Set up file watcher if we have local sources
+    let isSyncing = false;
+    let pendingSync = false;
+    const debounceMs = 2000;
+    let syncTimeout = null;
+    async function debouncedSync() {
+        if (isSyncing) {
+            pendingSync = true;
+            return;
+        }
+        isSyncing = true;
+        log('SYNC', 'File change detected, syncing...');
+        try {
+            const result = await runSync(false); // Don't git pull on file change
+            log('SYNC', `Sync complete: ${result.files_processed} files processed`);
+            for (const title of result.titles) {
+                log('INDEX', title);
+            }
+            updateStatus({
+                last_sync: new Date().toISOString(),
+                last_sync_result: {
+                    files_scanned: result.files_scanned,
+                    files_processed: result.files_processed,
+                    errors: result.errors,
+                },
+            });
+        }
+        catch (error) {
+            log('ERROR', `Sync failed: ${error}`);
+        }
+        isSyncing = false;
+        // If another sync was requested while we were syncing, run it
+        if (pendingSync) {
+            pendingSync = false;
+            debouncedSync();
+        }
+    }
+    function scheduleSync() {
+        if (syncTimeout) {
+            clearTimeout(syncTimeout);
+        }
+        syncTimeout = setTimeout(debouncedSync, debounceMs);
+    }
+    // Check if a file matches any configured source glob
+    function fileMatchesAnySource(filePath) {
+        for (const source of sources) {
+            const expanded = expandPath(source.path);
+            if (filePath.startsWith(expanded)) {
+                const relativePath = path.relative(expanded, filePath);
+                if (matchesGlob(relativePath, source.glob)) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+    // Set up file watcher
+    if (sources.length > 0) {
+        const chokidar = await import('chokidar');
+        const watchPaths = sources.map(s => expandPath(s.path));
+        const watcher = chokidar.watch(watchPaths, {
+            ignored: [
+                /(^|[\\/])\../, // Ignore dotfiles
+                /node_modules/,
+                /__pycache__/,
+                /\.lance$/,
+                /vectors\.lance/,
+                /\.db$/,
+                /\.sqlite$/,
+            ],
+            persistent: true,
+            ignoreInitial: true,
+            awaitWriteFinish: {
+                stabilityThreshold: 500,
+                pollInterval: 100,
+            },
+        });
+        watcher
+            .on('add', (filePath) => {
+            if (!fileMatchesAnySource(filePath))
+                return;
+            log('FILE', `Added: ${path.basename(filePath)}`);
+            scheduleSync();
+        })
+            .on('change', (filePath) => {
+            if (!fileMatchesAnySource(filePath))
+                return;
+            log('FILE', `Changed: ${path.basename(filePath)}`);
+            scheduleSync();
+        })
+            .on('error', (error) => {
+            log('ERROR', `Watcher error: ${error}`);
+        });
+        log('INFO', 'File watcher started');
+    }
+    // Periodic sync (git pull + full sync)
+    const PULL_INTERVAL_MS = 5 * 60 * 1000; // 5 minutes
+    async function periodicSync() {
+        if (isSyncing)
+            return;
+        log('PULL', 'Periodic sync starting...');
+        try {
+            const result = await runSync(true);
+            if (result.files_processed > 0) {
+                log('PULL', `Found ${result.files_processed} new file(s)`);
+                for (const title of result.titles) {
+                    log('INDEX', title);
+                }
+            }
+            else {
+                log('PULL', 'Up to date');
+            }
+            updateStatus({
+                last_sync: new Date().toISOString(),
+                last_sync_result: {
+                    files_scanned: result.files_scanned,
+                    files_processed: result.files_processed,
+                    errors: result.errors,
+                },
+            });
+        }
+        catch (error) {
+            log('ERROR', `Periodic sync failed: ${error}`);
+        }
+    }
+    // Run periodic sync
+    setInterval(periodicSync, PULL_INTERVAL_MS);
+    log('INFO', `Periodic sync every ${PULL_INTERVAL_MS / 60000} minutes`);
+    // Handle shutdown
+    process.on('SIGTERM', () => {
+        log('STOP', 'Daemon stopping (SIGTERM)');
+        process.exit(0);
+    });
+    process.on('SIGINT', () => {
+        log('STOP', 'Daemon stopping (SIGINT)');
+        process.exit(0);
+    });
+    log('INFO', 'Daemon ready');
+}
+main().catch((error) => {
+    log('FATAL', `Daemon crashed: ${error}`);
+    process.exit(1);
+});

package/dist/extensions/config.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Lore - Extension Configuration
+ *
+ * Stores installed extensions in ~/.config/lore/extensions.json
+ * Packages are installed under ~/.config/lore/extensions
+ */
+export interface ExtensionConfigEntry {
+    name: string;
+    version?: string;
+    enabled?: boolean;
+}
+export interface ExtensionConfig {
+    version: number;
+    extensions: ExtensionConfigEntry[];
+}
+export declare function getExtensionsDir(): string;
+export declare function getExtensionsConfigPath(): string;
+export declare function loadExtensionConfig(): Promise<ExtensionConfig>;
+export declare function saveExtensionConfig(config: ExtensionConfig): Promise<void>;
+export declare function ensureExtensionsDir(): Promise<void>;
+export declare function addExtensionToConfig(name: string, version?: string, enabled?: boolean): Promise<ExtensionConfig>;
+export declare function removeExtensionFromConfig(name: string): Promise<ExtensionConfig>;

package/dist/extensions/config.js

@@ -0,0 +1,102 @@
+/**
+ * Lore - Extension Configuration
+ *
+ * Stores installed extensions in ~/.config/lore/extensions.json
+ * Packages are installed under ~/.config/lore/extensions
+ */
+import { readFile, writeFile, mkdir } from 'fs/promises';
+import { existsSync } from 'fs';
+import path from 'path';
+import os from 'os';
+// ============================================================================
+// Paths
+// ============================================================================
+const CONFIG_DIR = path.join(os.homedir(), '.config', 'lore');
+const EXTENSIONS_DIR = path.join(CONFIG_DIR, 'extensions');
+const CONFIG_FILE = path.join(CONFIG_DIR, 'extensions.json');
+export function getExtensionsDir() {
+    return EXTENSIONS_DIR;
+}
+export function getExtensionsConfigPath() {
+    return CONFIG_FILE;
+}
+// ============================================================================
+// Defaults
+// ============================================================================
+function getDefaultConfig() {
+    return {
+        version: 1,
+        extensions: [],
+    };
+}
+// ============================================================================
+// Config IO
+// ============================================================================
+export async function loadExtensionConfig() {
+    if (!existsSync(CONFIG_FILE)) {
+        return getDefaultConfig();
+    }
+    try {
+        const content = await readFile(CONFIG_FILE, 'utf-8');
+        const config = JSON.parse(content);
+        if (config.version !== 1) {
+            console.warn(`[extensions] Unknown config version: ${config.version}, expected 1`);
+        }
+        if (!Array.isArray(config.extensions)) {
+            throw new Error('Invalid extensions config: extensions must be an array');
+        }
+        return config;
+    }
+    catch (error) {
+        if (error.code === 'ENOENT') {
+            return getDefaultConfig();
+        }
+        throw error;
+    }
+}
+export async function saveExtensionConfig(config) {
+    await mkdir(CONFIG_DIR, { recursive: true });
+    await writeFile(CONFIG_FILE, JSON.stringify(config, null, 2));
+}
+export async function ensureExtensionsDir() {
+    await mkdir(EXTENSIONS_DIR, { recursive: true });
+    const packageJsonPath = path.join(EXTENSIONS_DIR, 'package.json');
+    if (!existsSync(packageJsonPath)) {
+        const packageJson = {
+            name: 'lore-extensions',
+            private: true,
+            version: '0.0.0',
+            description: 'Installed Lore extensions',
+        };
+        await writeFile(packageJsonPath, JSON.stringify(packageJson, null, 2));
+    }
+}
+// ============================================================================
+// Config Manipulation
+// ============================================================================
+export async function addExtensionToConfig(name, version, enabled = true) {
+    const config = await loadExtensionConfig();
+    const existingIndex = config.extensions.findIndex((ext) => ext.name === name);
+    if (existingIndex !== -1) {
+        config.extensions[existingIndex] = {
+            ...config.extensions[existingIndex],
+            version: version ?? config.extensions[existingIndex].version,
+            enabled,
+        };
+    }
+    else {
+        config.extensions.push({ name, version, enabled });
+    }
+    await saveExtensionConfig(config);
+    return config;
+}
+export async function removeExtensionFromConfig(name) {
+    const config = await loadExtensionConfig();
+    const index = config.extensions.findIndex((ext) => ext.name === name);
+    if (index === -1) {
+        return config;
+    }
+    config.extensions.splice(index, 1);
+    await saveExtensionConfig(config);
+    return config;
+}

package/dist/extensions/proposals.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Proposal-based write system for extensions
+ */
+export interface ProposedChange {
+    type: 'create_source' | 'update_source' | 'delete_source' | 'retain_insight' | 'add_tags';
+    title?: string;
+    content?: string;
+    project?: string;
+    sourceId?: string;
+    changes?: Record<string, unknown>;
+    insight?: string;
+    tags?: string[];
+    reason: string;
+}
+export interface PendingProposal {
+    id: string;
+    extensionName: string;
+    change: ProposedChange;
+    createdAt: string;
+    status: 'pending' | 'approved' | 'rejected';
+    reviewedAt?: string;
+    rejectionReason?: string;
+}
+export declare function getPendingDir(): string;
+export declare function ensurePendingDir(): Promise<void>;
+export declare function createProposal(extensionName: string, change: ProposedChange): Promise<PendingProposal>;
+export declare function listPendingProposals(): Promise<PendingProposal[]>;
+export declare function getProposal(id: string): Promise<PendingProposal | null>;
+export declare function approveProposal(id: string, dbPath: string, dataDir: string): Promise<void>;
+export declare function rejectProposal(id: string, reason: string): Promise<void>;

package/dist/extensions/proposals.js

@@ -0,0 +1,178 @@
+/**
+ * Proposal-based write system for extensions
+ */
+import { randomUUID } from 'crypto';
+import { existsSync } from 'fs';
+import { mkdir, readFile, readdir, writeFile } from 'fs/promises';
+import os from 'os';
+import path from 'path';
+import { handleIngest } from '../mcp/handlers/ingest.js';
+import { handleRetain } from '../mcp/handlers/retain.js';
+import { getDatabase, getSourceById } from '../core/vector-store.js';
+export function getPendingDir() {
+    return path.join(os.homedir(), '.config', 'lore', 'pending');
+}
+export async function ensurePendingDir() {
+    await mkdir(getPendingDir(), { recursive: true });
+}
+function proposalPath(id) {
+    return path.join(getPendingDir(), `${id}.json`);
+}
+async function writeProposal(proposal) {
+    await ensurePendingDir();
+    await writeFile(proposalPath(proposal.id), JSON.stringify(proposal, null, 2));
+}
+export async function createProposal(extensionName, change) {
+    const proposal = {
+        id: randomUUID(),
+        extensionName,
+        change,
+        createdAt: new Date().toISOString(),
+        status: 'pending',
+    };
+    await writeProposal(proposal);
+    return proposal;
+}
+export async function listPendingProposals() {
+    const dir = getPendingDir();
+    if (!existsSync(dir)) {
+        return [];
+    }
+    const entries = await readdir(dir);
+    const proposals = [];
+    for (const entry of entries) {
+        if (!entry.endsWith('.json'))
+            continue;
+        try {
+            const content = await readFile(path.join(dir, entry), 'utf-8');
+            const parsed = JSON.parse(content);
+            if (parsed?.id) {
+                proposals.push(parsed);
+            }
+        }
+        catch {
+            // Skip unreadable proposals
+        }
+    }
+    proposals.sort((a, b) => new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime());
+    return proposals;
+}
+export async function getProposal(id) {
+    const filePath = proposalPath(id);
+    if (!existsSync(filePath)) {
+        return null;
+    }
+    try {
+        const content = await readFile(filePath, 'utf-8');
+        return JSON.parse(content);
+    }
+    catch {
+        return null;
+    }
+}
+async function applyProposalChange(proposal, dbPath, dataDir) {
+    const change = proposal.change;
+    switch (change.type) {
+        case 'create_source': {
+            if (!change.title || !change.content || !change.project) {
+                throw new Error('create_source requires title, content, and project');
+            }
+            await handleIngest(dbPath, dataDir, {
+                title: change.title,
+                content: change.content,
+                project: change.project,
+            }, { hookContext: { mode: 'cli' } });
+            return;
+        }
+        case 'retain_insight': {
+            if (!change.insight) {
+                throw new Error('retain_insight requires insight');
+            }
+            const project = change.project || proposal.extensionName;
+            await handleRetain(dbPath, dataDir, {
+                content: change.insight,
+                project,
+                type: 'insight',
+            }, {});
+            return;
+        }
+        case 'update_source': {
+            if (!change.sourceId || !change.changes) {
+                throw new Error('update_source requires sourceId and changes');
+            }
+            const client = await getDatabase(dbPath);
+            const { error } = await client
+                .from('sources')
+                .update(change.changes)
+                .eq('id', change.sourceId);
+            if (error) {
+                throw error;
+            }
+            return;
+        }
+        case 'add_tags': {
+            if (!change.sourceId || !change.tags) {
+                throw new Error('add_tags requires sourceId and tags');
+            }
+            const source = await getSourceById(dbPath, change.sourceId);
+            if (!source) {
+                throw new Error(`Source not found: ${change.sourceId}`);
+            }
+            const existing = Array.isArray(source.tags) ? source.tags : [];
+            const merged = Array.from(new Set([...existing, ...change.tags]));
+            const client = await getDatabase(dbPath);
+            const { error } = await client
+                .from('sources')
+                .update({ tags: merged })
+                .eq('id', change.sourceId);
+            if (error) {
+                throw error;
+            }
+            return;
+        }
+        case 'delete_source': {
+            if (!change.sourceId) {
+                throw new Error('delete_source requires sourceId');
+            }
+            const client = await getDatabase(dbPath);
+            const { error } = await client
+                .from('sources')
+                .delete()
+                .eq('id', change.sourceId);
+            if (error) {
+                throw error;
+            }
+            return;
+        }
+        default: {
+            const exhaustive = change.type;
+            throw new Error(`Unknown proposal type: ${exhaustive}`);
+        }
+    }
+}
+export async function approveProposal(id, dbPath, dataDir) {
+    const proposal = await getProposal(id);
+    if (!proposal) {
+        throw new Error(`Proposal not found: ${id}`);
+    }
+    if (proposal.status !== 'pending') {
+        throw new Error(`Proposal ${id} is already ${proposal.status}`);
+    }
+    await applyProposalChange(proposal, dbPath, dataDir);
+    proposal.status = 'approved';
+    proposal.reviewedAt = new Date().toISOString();
+    await writeProposal(proposal);
+}
+export async function rejectProposal(id, reason) {
+    const proposal = await getProposal(id);
+    if (!proposal) {
+        throw new Error(`Proposal not found: ${id}`);
+    }
+    if (proposal.status !== 'pending') {
+        throw new Error(`Proposal ${id} is already ${proposal.status}`);
+    }
+    proposal.status = 'rejected';
+    proposal.reviewedAt = new Date().toISOString();
+    proposal.rejectionReason = reason;
+    await writeProposal(proposal);
+}

package/dist/extensions/registry.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Lore Extension Registry + Loader
+ */
+import type { LoreExtension, ExtensionToolContext, ExtensionCommandContext, ExtensionPermissions, LoreEventType } from './types.js';
+import type { Command } from 'commander';
+interface LoadedExtension {
+    extension: LoreExtension;
+    packageName: string;
+    modulePath: string;
+}
+interface ExtensionRegistryOptions {
+    extensionsDir?: string;
+    logger?: (message: string) => void;
+    loreVersion?: string;
+    cacheBust?: string;
+}
+export declare function createProposeFunction(extensionName: string, permissions?: ExtensionPermissions): (change: import('./proposals.js').ProposedChange) => Promise<import('./proposals.js').PendingProposal>;
+export declare class ExtensionRegistry {
+    private extensions;
+    private readonly logger;
+    private readonly options;
+    constructor(extensions: LoadedExtension[], logger: (message: string) => void, options: ExtensionRegistryOptions);
+    listExtensions(): LoadedExtension[];
+    private collectMiddleware;
+    private collectEventHandlers;
+    emitEvent(type: LoreEventType, payload: unknown, context: ExtensionToolContext): Promise<void>;
+    registerCommands(program: Command, context: ExtensionCommandContext): void;
+    runHook(hookName: keyof NonNullable<LoreExtension['hooks']>, payload: unknown, context: ExtensionToolContext): Promise<void>;
+    reload(): Promise<void>;
+}
+export declare function loadExtensionRegistry(options?: ExtensionRegistryOptions): Promise<ExtensionRegistry>;
+export declare function getExtensionRegistry(options?: ExtensionRegistryOptions): Promise<ExtensionRegistry>;
+export declare function clearExtensionRegistry(): void;
+export declare function getLoreVersionString(): Promise<string | undefined>;
+export {};