@getlore/cli 0.2.0

package/dist/extensions/registry.js

@@ -0,0 +1,309 @@
+/**
+ * Lore Extension Registry + Loader
+ */
+import { createRequire } from 'module';
+import path from 'path';
+import { readFile } from 'fs/promises';
+import { fileURLToPath, pathToFileURL } from 'url';
+import { getExtensionsDir, loadExtensionConfig, } from './config.js';
+import { getAllSources } from '../core/vector-store.js';
+import { createProposal } from './proposals.js';
+function getLogger(logger) {
+    return logger || ((message) => console.error(message));
+}
+function createQueryFunction() {
+    return async (options) => {
+        try {
+            // Get all sources for project (search with embeddings requires more complex setup)
+            const results = await getAllSources('', {
+                project: options.project,
+                limit: options.limit || 100,
+                source_type: options.sourceType,
+            });
+            return results.map((r) => ({
+                id: r.id,
+                title: r.title,
+                summary: r.summary || '',
+                projects: r.projects || [],
+                created_at: r.created_at,
+            }));
+        }
+        catch (error) {
+            console.error('[extensions] Query failed:', error);
+            return [];
+        }
+    };
+}
+function createAskFunction(dbPath) {
+    return async (question, options = {}) => {
+        try {
+            // Lazy import to avoid circular dependencies
+            const { default: Anthropic } = await import('@anthropic-ai/sdk');
+            const { searchSources } = await import('../core/vector-store.js');
+            const { generateEmbedding } = await import('../core/embedder.js');
+            if (!process.env.ANTHROPIC_API_KEY) {
+                throw new Error('ANTHROPIC_API_KEY not set');
+            }
+            // Search for relevant sources
+            const embedding = await generateEmbedding(question);
+            const sources = await searchSources(dbPath, embedding, {
+                limit: options.maxSources || 10,
+                project: options.project,
+                queryText: question,
+                mode: 'hybrid',
+            });
+            if (sources.length === 0) {
+                return 'No relevant sources found.';
+            }
+            // Build context
+            const sourceContext = sources.map((s, i) => {
+                return `[Source ${i + 1}: ${s.title}]\n${s.summary}`;
+            }).join('\n\n---\n\n');
+            // Call AI
+            const anthropic = new Anthropic();
+            const response = await anthropic.messages.create({
+                model: 'claude-sonnet-4-20250514',
+                max_tokens: 2048,
+                system: 'You are a research assistant. Answer based on the provided sources. Be concise.',
+                messages: [{
+                        role: 'user',
+                        content: `Question: ${question}\n\n---\nSources:\n${sourceContext}`
+                    }],
+            });
+            const textBlocks = response.content.filter(block => block.type === 'text');
+            return textBlocks.map(block => block.text).join('\n');
+        }
+        catch (error) {
+            console.error('[extensions] Ask failed:', error);
+            throw error;
+        }
+    };
+}
+export function createProposeFunction(extensionName, permissions) {
+    return async (change) => {
+        // Enforce permissions
+        const perms = permissions || {};
+        if (change.type === 'create_source' || change.type === 'retain_insight') {
+            if (!perms.proposeCreate) {
+                throw new Error(`Extension "${extensionName}" does not have permission to propose creating documents. Add permissions.proposeCreate = true to the extension.`);
+            }
+        }
+        if (change.type === 'update_source' || change.type === 'add_tags') {
+            if (!perms.proposeModify) {
+                throw new Error(`Extension "${extensionName}" does not have permission to propose modifications. Add permissions.proposeModify = true to the extension.`);
+            }
+        }
+        if (change.type === 'delete_source') {
+            if (!perms.proposeDelete) {
+                throw new Error(`Extension "${extensionName}" does not have permission to propose deletions. Add permissions.proposeDelete = true to the extension.`);
+            }
+        }
+        return createProposal(extensionName, change);
+    };
+}
+async function resolveLoreExtension(mod) {
+    const candidate = mod.loreExtension ||
+        mod.default;
+    if (!candidate) {
+        return null;
+    }
+    if (typeof candidate === 'function') {
+        const result = await candidate();
+        return result;
+    }
+    return candidate;
+}
+function validateExtension(extension, logger) {
+    if (!extension.name || !extension.version) {
+        logger(`[extensions] Skipping extension with missing name/version`);
+        return false;
+    }
+    return true;
+}
+function checkCompatibility(extension, loreVersion, logger) {
+    const required = extension.compatibility?.loreVersion;
+    if (!required || !loreVersion) {
+        return;
+    }
+    if (required !== loreVersion) {
+        logger(`[extensions] Compatibility warning: ${extension.name} requires Lore ${required}, current ${loreVersion}`);
+    }
+}
+async function getLoreVersion() {
+    const explicit = process.env.LORE_VERSION || process.env.npm_package_version;
+    if (explicit) {
+        return explicit;
+    }
+    try {
+        const here = path.dirname(fileURLToPath(import.meta.url));
+        const packageJsonPath = path.resolve(here, '../../package.json');
+        const content = await readFile(packageJsonPath, 'utf-8');
+        const parsed = JSON.parse(content);
+        return parsed.version;
+    }
+    catch {
+        return undefined;
+    }
+}
+export class ExtensionRegistry {
+    extensions;
+    logger;
+    options;
+    constructor(extensions, logger, options) {
+        this.extensions = extensions;
+        this.logger = logger;
+        this.options = options;
+    }
+    listExtensions() {
+        return [...this.extensions];
+    }
+    collectMiddleware() {
+        const chain = [];
+        for (const loaded of this.extensions) {
+            const middleware = loaded.extension.middleware || [];
+            for (const entry of middleware) {
+                if (!entry?.name) {
+                    this.logger(`[extensions] Skipping unnamed middleware in ${loaded.extension.name}`);
+                    continue;
+                }
+                chain.push(entry);
+            }
+        }
+        return chain;
+    }
+    collectEventHandlers(type) {
+        const handlers = [];
+        for (const loaded of this.extensions) {
+            const handler = loaded.extension.events?.[type];
+            if (handler) {
+                handlers.push(handler);
+            }
+        }
+        return handlers;
+    }
+    async emitEvent(type, payload, context) {
+        const event = {
+            type,
+            payload,
+            timestamp: Date.now(),
+        };
+        const handlers = this.collectEventHandlers(type);
+        for (const handler of handlers) {
+            try {
+                await handler(event, {
+                    ...context,
+                    logger: context.logger || this.logger,
+                });
+            }
+            catch (error) {
+                this.logger(`[extensions] Event ${type} handler failed: ${error instanceof Error ? error.message : String(error)}`);
+            }
+        }
+    }
+    registerCommands(program, context) {
+        for (const loaded of this.extensions) {
+            const commands = loaded.extension.commands || [];
+            for (const command of commands) {
+                try {
+                    command.register(program, {
+                        ...context,
+                        logger: context.logger || this.logger,
+                    });
+                }
+                catch (error) {
+                    this.logger(`[extensions] Failed to register command ${command.name} from ${loaded.extension.name}: ${String(error)}`);
+                }
+            }
+        }
+    }
+    async runHook(hookName, payload, context) {
+        for (const loaded of this.extensions) {
+            const hook = loaded.extension.hooks?.[hookName];
+            if (!hook) {
+                continue;
+            }
+            try {
+                await hook(payload, {
+                    ...context,
+                    logger: context.logger || this.logger,
+                });
+            }
+            catch (error) {
+                this.logger(`[extensions] Hook ${String(hookName)} failed in ${loaded.extension.name}: ${error instanceof Error ? error.message : String(error)}`);
+            }
+        }
+    }
+    async reload() {
+        this.logger('[extensions] Reloading extensions');
+        const cacheBust = `${Date.now()}`;
+        const updated = await loadExtensionRegistry({
+            ...this.options,
+            logger: this.logger,
+            cacheBust,
+        });
+        this.extensions = updated.extensions;
+        this.logger('[extensions] Extensions reloaded');
+    }
+}
+export async function loadExtensionRegistry(options = {}) {
+    const logger = getLogger(options.logger);
+    const loreVersion = options.loreVersion ?? (await getLoreVersion());
+    const extensionsDir = options.extensionsDir || getExtensionsDir();
+    const resolvedOptions = {
+        ...options,
+        logger,
+        loreVersion,
+        extensionsDir,
+    };
+    const config = await loadExtensionConfig();
+    const enabledExtensions = config.extensions.filter((ext) => ext.enabled !== false);
+    const loadedExtensions = [];
+    const require = createRequire(import.meta.url);
+    for (const entry of enabledExtensions) {
+        const loaded = await loadSingleExtension(entry, extensionsDir, require, loreVersion, logger, options.cacheBust);
+        if (!loaded) {
+            continue;
+        }
+        loadedExtensions.push(loaded);
+    }
+    return new ExtensionRegistry(loadedExtensions, logger, resolvedOptions);
+}
+async function loadSingleExtension(entry, extensionsDir, require, loreVersion, logger, cacheBust) {
+    try {
+        const resolved = require.resolve(entry.name, { paths: [extensionsDir] });
+        const moduleUrl = pathToFileURL(resolved).href;
+        const importUrl = cacheBust ? `${moduleUrl}?t=${cacheBust}` : moduleUrl;
+        const mod = await import(importUrl);
+        const extension = await resolveLoreExtension(mod);
+        if (!extension) {
+            logger(`[extensions] ${entry.name} does not export a Lore extension`);
+            return null;
+        }
+        if (!validateExtension(extension, logger)) {
+            return null;
+        }
+        checkCompatibility(extension, loreVersion, logger);
+        return {
+            extension,
+            packageName: entry.name,
+            modulePath: resolved,
+        };
+    }
+    catch (error) {
+        logger(`[extensions] Failed to load ${entry.name}: ${error instanceof Error ? error.message : String(error)}`);
+        return null;
+    }
+}
+let registryPromise = null;
+export async function getExtensionRegistry(options = {}) {
+    if (!registryPromise) {
+        registryPromise = loadExtensionRegistry(options);
+    }
+    return registryPromise;
+}
+export function clearExtensionRegistry() {
+    registryPromise = null;
+}
+export async function getLoreVersionString() {
+    return getLoreVersion();
+}

package/dist/extensions/sandbox.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Extension Sandbox
+ *
+ * Placeholder for potential future sandboxed execution of extension hooks/middleware.
+ * Tool handling has been removed - extensions are now event-driven middleware only.
+ */
+export interface ExtensionSandboxOptions {
+    logger: (message: string) => void;
+    timeoutMs?: number;
+}
+export declare class ExtensionSandbox {
+    private readonly logger;
+    private readonly timeoutMs;
+    constructor(options: ExtensionSandboxOptions);
+    dispose(): void;
+}

package/dist/extensions/sandbox.js

@@ -0,0 +1,17 @@
+/**
+ * Extension Sandbox
+ *
+ * Placeholder for potential future sandboxed execution of extension hooks/middleware.
+ * Tool handling has been removed - extensions are now event-driven middleware only.
+ */
+export class ExtensionSandbox {
+    logger;
+    timeoutMs;
+    constructor(options) {
+        this.logger = options.logger;
+        this.timeoutMs = options.timeoutMs ?? 30_000;
+    }
+    dispose() {
+        // No-op for now
+    }
+}

package/dist/extensions/types.d.ts

@@ -0,0 +1,114 @@
+/**
+ * Lore Extension Types
+ */
+import type { Command } from 'commander';
+import type { ResearchPackage } from '../core/types.js';
+import type { ProposedChange, PendingProposal } from './proposals.js';
+export interface ExtensionQueryOptions {
+    query?: string;
+    project?: string;
+    limit?: number;
+    sourceType?: string;
+}
+export interface ExtensionQueryResult {
+    id: string;
+    title: string;
+    summary: string;
+    content?: string;
+    projects: string[];
+    participants?: string[];
+    created_at: string;
+    score?: number;
+}
+export interface ExtensionPermissions {
+    read?: boolean;
+    proposeCreate?: boolean;
+    proposeModify?: boolean;
+    proposeDelete?: boolean;
+}
+export interface AskOptions {
+    project?: string;
+    maxSources?: number;
+}
+export interface ExtensionToolContext {
+    mode: 'mcp' | 'cli';
+    dataDir?: string;
+    dbPath?: string;
+    logger?: (message: string) => void;
+    query?: (options: ExtensionQueryOptions) => Promise<ExtensionQueryResult[]>;
+    ask?: (question: string, options?: AskOptions) => Promise<string>;
+    propose?: (change: ProposedChange) => Promise<PendingProposal>;
+}
+export interface ExtensionMiddleware {
+    name: string;
+    beforeToolCall?: (toolName: string, args: Record<string, unknown>, context: ExtensionToolContext) => Promise<{
+        args?: Record<string, unknown>;
+        skip?: boolean;
+        result?: unknown;
+    }>;
+    afterToolCall?: (toolName: string, args: Record<string, unknown>, result: unknown, context: ExtensionToolContext) => Promise<unknown>;
+}
+export type LoreEventType = 'search' | 'ingest' | 'sync' | 'tool.call' | 'tool.result' | 'startup' | 'shutdown';
+export interface LoreEvent {
+    type: LoreEventType;
+    payload: unknown;
+    timestamp: number;
+}
+export type EventHandler = (event: LoreEvent, context: ExtensionToolContext) => void | Promise<void>;
+export interface ExtensionCommandContext {
+    defaultDataDir: string;
+    logger?: (message: string) => void;
+}
+export interface ExtensionCommand {
+    name: string;
+    description?: string;
+    register: (program: Command, context: ExtensionCommandContext) => void | Promise<void>;
+}
+export interface SourceCreatedEvent {
+    id: string;
+    title: string;
+    source_type: string;
+    content_type: string;
+    created_at: string;
+    imported_at: string;
+    projects: string[];
+    tags: string[];
+    source_path?: string;
+    content_hash?: string;
+    sync_source?: string;
+    original_file?: string;
+}
+export interface SyncCompletedEvent {
+    newDocs: number;
+    updatedDocs: number;
+    totalDocs: number;
+    project?: string;
+}
+export interface ExtensionHooks {
+    /** Called when a new source is indexed */
+    onSourceCreated?: (event: SourceCreatedEvent, context: ExtensionToolContext) => void | Promise<void>;
+    /** Called when research completes */
+    onResearchCompleted?: (result: ResearchPackage, context: ExtensionToolContext) => void | Promise<void>;
+    /** Called when sync completes */
+    onSyncCompleted?: (event: SyncCompletedEvent, context: ExtensionToolContext) => void | Promise<void>;
+}
+export interface ComponentDefinition {
+    id: string;
+    description?: string;
+}
+export interface ExtensionCompatibility {
+    loreVersion?: string;
+}
+export interface LoreExtension {
+    name: string;
+    version: string;
+    compatibility?: ExtensionCompatibility;
+    permissions?: ExtensionPermissions;
+    commands?: ExtensionCommand[];
+    hooks?: ExtensionHooks;
+    components?: ComponentDefinition[];
+    middleware?: ExtensionMiddleware[];
+    events?: {
+        [K in LoreEventType]?: EventHandler;
+    };
+}

package/dist/extensions/types.js

@@ -0,0 +1,4 @@
+/**
+ * Lore Extension Types
+ */
+export {};

package/dist/extensions/worker.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/extensions/worker.js

@@ -0,0 +1,49 @@
+import { parentPort, workerData } from 'worker_threads';
+import { pathToFileURL } from 'url';
+const initData = workerData;
+function getErrorMessage(error) {
+    if (error instanceof Error) {
+        return error.message;
+    }
+    return String(error);
+}
+async function resolveLoreExtension(mod) {
+    const candidate = mod.loreExtension ||
+        mod.default;
+    if (!candidate) {
+        return null;
+    }
+    if (typeof candidate === 'function') {
+        const result = await candidate();
+        return result;
+    }
+    return candidate;
+}
+let extension = null;
+let extensionLoadError = null;
+const extensionReady = (async () => {
+    try {
+        const moduleUrl = pathToFileURL(initData.modulePath).href;
+        const importUrl = initData.cacheBust ? `${moduleUrl}?t=${initData.cacheBust}` : moduleUrl;
+        const mod = await import(importUrl);
+        const resolved = await resolveLoreExtension(mod);
+        if (!resolved) {
+            throw new Error(`${initData.modulePath} does not export a Lore extension`);
+        }
+        extension = resolved;
+    }
+    catch (error) {
+        extensionLoadError = getErrorMessage(error);
+        console.error(`[extensions] Worker failed to load extension: ${extensionLoadError}`);
+    }
+})();
+if (!parentPort) {
+    throw new Error('Worker must be started with a parent port');
+}
+// Worker is now primarily used for sandboxed hook/middleware execution
+// Tool handling has been removed - extensions are event-driven middleware only
+const port = parentPort;
+port.on('message', async () => {
+    await extensionReady;
+    // No-op for now - hooks and middleware are executed in the main thread
+});

package/dist/index.d.ts

@@ -0,0 +1,17 @@
+#!/usr/bin/env node
+/**
+ * Lore CLI
+ *
+ * Research knowledge repository with semantic search and citations.
+ *
+ * Commands:
+ * - sync: Sync and manage the knowledge repository (daemon, watch, sources, import)
+ * - search: Search the knowledge base
+ * - research: Deep AI-powered research
+ * - browse: Interactive TUI browser
+ * - docs: Document CRUD (list, get, create, delete)
+ * - projects: Project management (list, archive, delete)
+ * - init: Initialize a data repository
+ * - serve: Start the MCP server
+ */
+export {};

package/dist/index.js

@@ -0,0 +1,105 @@
+#!/usr/bin/env node
+/**
+ * Lore CLI
+ *
+ * Research knowledge repository with semantic search and citations.
+ *
+ * Commands:
+ * - sync: Sync and manage the knowledge repository (daemon, watch, sources, import)
+ * - search: Search the knowledge base
+ * - research: Deep AI-powered research
+ * - browse: Interactive TUI browser
+ * - docs: Document CRUD (list, get, create, delete)
+ * - projects: Project management (list, archive, delete)
+ * - init: Initialize a data repository
+ * - serve: Start the MCP server
+ */
+// Load environment variables from .env files
+// .env.local takes precedence over .env
+import { existsSync, readFileSync } from 'fs';
+import { parse } from 'dotenv';
+import { Command } from 'commander';
+import { registerSyncCommand } from './cli/commands/sync.js';
+import { registerSearchCommand } from './cli/commands/search.js';
+import { registerMiscCommands } from './cli/commands/misc.js';
+import { registerDocsCommand } from './cli/commands/docs.js';
+import { registerProjectsCommand } from './cli/commands/projects.js';
+import { registerExtensionCommands } from './cli/commands/extensions.js';
+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 { getExtensionRegistry, getLoreVersionString } from './extensions/registry.js';
+import { bridgeConfigToEnv } from './core/config.js';
+import { expandPath } from './sync/config.js';
+// Load .env files silently (without the v17 logging)
+function loadEnvFile(filePath, override = false) {
+    if (!existsSync(filePath))
+        return;
+    try {
+        const content = readFileSync(filePath, 'utf-8');
+        const parsed = parse(content);
+        for (const [key, value] of Object.entries(parsed)) {
+            if (override || process.env[key] === undefined) {
+                process.env[key] = value;
+            }
+        }
+    }
+    catch {
+        // Silently ignore errors
+    }
+}
+// Load .env first, then .env.local (overrides)
+loadEnvFile('.env');
+loadEnvFile('.env.local', true);
+// Bridge config.json values into process.env (env vars take precedence)
+try {
+    await bridgeConfigToEnv();
+}
+catch {
+    // Config not set up yet — fine, user may be running `lore setup`
+}
+// Default data directory
+const DEFAULT_DATA_DIR = expandPath(process.env.LORE_DATA_DIR || '~/.lore');
+// Create program
+const program = new Command();
+program
+    .name('lore')
+    .description('Research knowledge repository with semantic search and citations')
+    .version((await getLoreVersionString()) || '0.1.0');
+// Register all commands
+registerSyncCommand(program, DEFAULT_DATA_DIR);
+registerSearchCommand(program, DEFAULT_DATA_DIR);
+registerDocsCommand(program, DEFAULT_DATA_DIR);
+registerProjectsCommand(program, DEFAULT_DATA_DIR);
+registerMiscCommands(program, DEFAULT_DATA_DIR);
+registerAskCommand(program, DEFAULT_DATA_DIR);
+registerAuthCommands(program);
+registerSkillsCommand(program);
+// Extension system — hidden from top-level help for now
+const extensionCmd = registerExtensionCommands(program);
+extensionCmd._hidden = true;
+registerPendingCommand(extensionCmd, DEFAULT_DATA_DIR);
+try {
+    const extensionRegistry = await getExtensionRegistry({
+        logger: (message) => console.error(message),
+    });
+    extensionRegistry.registerCommands(program, {
+        defaultDataDir: DEFAULT_DATA_DIR,
+    });
+}
+catch {
+    // Extensions not loaded — fine for initial release
+}
+// Global error handler — show friendly messages instead of stack traces
+process.on('uncaughtException', (error) => {
+    console.error(`\nError: ${error.message}`);
+    process.exit(1);
+});
+process.on('unhandledRejection', (reason) => {
+    const message = reason instanceof Error ? reason.message : String(reason);
+    console.error(`\nError: ${message}`);
+    process.exit(1);
+});
+// Parse and run
+program.parse();

package/dist/mcp/handlers/archive-project.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Archive Project Handler - Mark a project as archived
+ *
+ * Archived projects are excluded from search by default but preserved for history.
+ * This is a human-triggered curation action, not automatic.
+ * Auto-pushes to git remote if configured.
+ */
+interface ArchivedProject {
+    project: string;
+    archived_at: string;
+    reason?: string;
+    successor_project?: string;
+}
+interface ArchiveProjectArgs {
+    project: string;
+    reason?: string;
+    successor_project?: string;
+}
+interface ArchiveProjectResult {
+    success: boolean;
+    project: string;
+    archived_at: string;
+    reason?: string;
+    successor_project?: string;
+    sources_affected: number;
+    synced?: boolean;
+    error?: string;
+}
+/**
+ * Load archived projects list
+ */
+export declare function loadArchivedProjects(dataDir: string): Promise<ArchivedProject[]>;
+/**
+ * Check if a project is archived
+ */
+export declare function isProjectArchived(dataDir: string, project: string): Promise<boolean>;
+/**
+ * Get archived project info
+ */
+export declare function getArchivedProjectInfo(dataDir: string, project: string): Promise<ArchivedProject | null>;
+export declare function handleArchiveProject(dbPath: string, dataDir: string, args: ArchiveProjectArgs, options?: {
+    autoPush?: boolean;
+}): Promise<ArchiveProjectResult>;
+/**
+ * Unarchive a project (restore to active)
+ */
+export declare function handleUnarchiveProject(dataDir: string, project: string): Promise<{
+    success: boolean;
+    error?: string;
+}>;
+export {};