@getlore/cli 0.2.0

package/dist/cli/commands/skills.js

@@ -0,0 +1,447 @@
+/**
+ * Skills Command
+ *
+ * Install Lore agent instruction files into the correct locations
+ * for each supported agent platform, using native plugin/extension formats.
+ *
+ * Each platform gets:
+ * 1. MCP server configuration (so Lore auto-starts)
+ * 2. Instruction/skill files (so the agent knows how to use Lore)
+ *
+ * lore skills list                    — show available skills
+ * lore skills install claude-code     — install Claude Code plugin (MCP + skill)
+ * lore skills install gemini          — install Gemini CLI extension (MCP + GEMINI.md)
+ * lore skills install codex           — install Codex CLI skill (MCP + SKILL.md)
+ * lore skills install openclaw        — install OpenClaw skill (SKILL.md)
+ * lore skills install generic         — print generic instructions to stdout
+ */
+import { existsSync, readFileSync, mkdirSync, writeFileSync, appendFileSync, cpSync, } from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import { c } from '../colors.js';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+// ── Path Resolution ─────────────────────────────────────────────────────
+function packageRoot() {
+    return path.resolve(__dirname, '..', '..', '..');
+}
+function pluginsDir() {
+    const dir = path.join(packageRoot(), 'plugins');
+    if (existsSync(dir))
+        return dir;
+    throw new Error(`Plugins directory not found at ${dir}`);
+}
+function skillsDir() {
+    const dir = path.join(packageRoot(), 'skills');
+    if (existsSync(dir))
+        return dir;
+    throw new Error(`Skills directory not found at ${dir}`);
+}
+function homeDir() {
+    return process.env.HOME || process.env.USERPROFILE || '~';
+}
+const LORE_MARKER = '# Lore Knowledge Base';
+const AVAILABLE_SKILLS = [
+    {
+        name: 'claude-code',
+        description: 'Claude Code plugin (MCP server + skill)',
+        native: '/plugin install — from marketplace or local',
+    },
+    {
+        name: 'gemini',
+        description: 'Gemini CLI extension (MCP server + context)',
+        native: 'gemini extensions install <repo>',
+    },
+    {
+        name: 'codex',
+        description: 'Codex CLI skill (MCP + SKILL.md)',
+        native: '$skill-installer inside Codex',
+    },
+    {
+        name: 'openclaw',
+        description: 'OpenClaw skill (SKILL.md)',
+        native: 'clawhub install lore',
+    },
+    {
+        name: 'generic',
+        description: 'Platform-agnostic instructions (stdout)',
+        native: 'N/A',
+    },
+];
+// ── Helpers ─────────────────────────────────────────────────────────────
+/**
+ * Merge Lore MCP server config into a project's .mcp.json.
+ * Creates the file if it doesn't exist.
+ */
+function mergeMcpJson(targetPath) {
+    const loreServer = {
+        command: 'npx',
+        args: ['-y', '@getlore/cli', 'mcp'],
+    };
+    let config = { mcpServers: {} };
+    if (existsSync(targetPath)) {
+        try {
+            config = JSON.parse(readFileSync(targetPath, 'utf-8'));
+        }
+        catch {
+            // Corrupted file — overwrite
+        }
+    }
+    const servers = (config.mcpServers || config);
+    if (servers.lore) {
+        return { added: false, path: targetPath };
+    }
+    servers.lore = loreServer;
+    if (!config.mcpServers) {
+        config = { mcpServers: servers };
+    }
+    mkdirSync(path.dirname(targetPath), { recursive: true });
+    writeFileSync(targetPath, JSON.stringify(config, null, 2) + '\n');
+    return { added: true, path: targetPath };
+}
+/**
+ * Append content to a file if the marker isn't already present.
+ */
+function appendIfMissing(filepath, content) {
+    mkdirSync(path.dirname(filepath), { recursive: true });
+    if (existsSync(filepath)) {
+        const existing = readFileSync(filepath, 'utf-8');
+        if (existing.includes(LORE_MARKER))
+            return 'exists';
+        appendFileSync(filepath, '\n\n' + content);
+        return 'appended';
+    }
+    writeFileSync(filepath, content);
+    return 'created';
+}
+/**
+ * Copy a directory recursively.
+ */
+function copyDir(src, dest) {
+    mkdirSync(dest, { recursive: true });
+    cpSync(src, dest, { recursive: true });
+}
+// ── Installers ──────────────────────────────────────────────────────────
+function installClaudeCode(options) {
+    const lines = [];
+    const pluginSrc = path.join(pluginsDir(), 'claude-code');
+    if (options.global) {
+        // Global: install plugin to ~/.lore/plugins/claude-code/ + add MCP to ~/.claude.json
+        const dest = path.join(homeDir(), '.lore', 'plugins', 'claude-code');
+        copyDir(pluginSrc, dest);
+        lines.push(`${c.success('Installed')} plugin to ${c.file(dest)}`);
+        // Try to add MCP to user-level config
+        const claudeJsonPath = path.join(homeDir(), '.claude.json');
+        const mcp = mergeMcpJson(claudeJsonPath);
+        if (mcp.added) {
+            lines.push(`${c.success('Added')} Lore MCP server to ${c.file(mcp.path)}`);
+        }
+        else {
+            lines.push(`${c.dim('MCP server already configured in')} ${c.file(mcp.path)}`);
+        }
+        lines.push('');
+        lines.push(c.dim('To activate the plugin in Claude Code, run:'));
+        lines.push(c.bold(`  claude --plugin-dir ${dest}`));
+    }
+    else {
+        // Project-level: add MCP to .mcp.json + install skill to .claude/rules/
+        const mcpJsonPath = path.join(process.cwd(), '.mcp.json');
+        const mcp = mergeMcpJson(mcpJsonPath);
+        if (mcp.added) {
+            lines.push(`${c.success('Added')} Lore MCP server to ${c.file(mcp.path)}`);
+        }
+        else {
+            lines.push(`${c.dim('MCP server already configured in')} ${c.file(mcp.path)}`);
+        }
+        // Install skill as a rule file
+        const skillContent = readFileSync(path.join(pluginSrc, 'skills', 'lore', 'SKILL.md'), 'utf-8');
+        // Strip YAML frontmatter for rules file
+        const body = skillContent.replace(/^---[\s\S]*?---\n*/, '');
+        const rulesPath = path.join(process.cwd(), '.claude', 'rules', 'lore.md');
+        const result = appendIfMissing(rulesPath, body);
+        if (result === 'exists') {
+            lines.push(`${c.dim('Instructions already in')} ${c.file(rulesPath)}`);
+        }
+        else {
+            lines.push(`${c.success(result === 'created' ? 'Created' : 'Appended to')} ${c.file(rulesPath)}`);
+        }
+        // Also copy the full plugin for reference
+        const pluginDest = path.join(homeDir(), '.lore', 'plugins', 'claude-code');
+        copyDir(pluginSrc, pluginDest);
+        lines.push('');
+        lines.push(c.dim('Claude Code will auto-start the Lore MCP server for this project.'));
+        lines.push(c.dim('For the full plugin experience (marketplace distribution):'));
+        lines.push(c.bold(`  claude --plugin-dir ${pluginDest}`));
+    }
+    return lines.join('\n');
+}
+function installGemini(options) {
+    const lines = [];
+    const extensionSrc = path.join(pluginsDir(), 'gemini');
+    if (options.global) {
+        // Install extension to ~/.lore/plugins/gemini/ and add context to ~/.gemini/GEMINI.md
+        const dest = path.join(homeDir(), '.lore', 'plugins', 'gemini');
+        copyDir(extensionSrc, dest);
+        lines.push(`${c.success('Installed')} extension to ${c.file(dest)}`);
+        const geminiMd = readFileSync(path.join(extensionSrc, 'GEMINI.md'), 'utf-8');
+        const globalPath = path.join(homeDir(), '.gemini', 'GEMINI.md');
+        const result = appendIfMissing(globalPath, geminiMd);
+        if (result === 'exists') {
+            lines.push(`${c.dim('Instructions already in')} ${c.file(globalPath)}`);
+        }
+        else {
+            lines.push(`${c.success(result === 'created' ? 'Created' : 'Appended to')} ${c.file(globalPath)}`);
+        }
+        lines.push('');
+        lines.push(c.dim('For native extension install (auto-starts MCP server):'));
+        lines.push(c.bold(`  gemini extensions install ${dest}`));
+    }
+    else {
+        // Project-level: install extension locally
+        const dest = path.join(homeDir(), '.lore', 'plugins', 'gemini');
+        copyDir(extensionSrc, dest);
+        const geminiMd = readFileSync(path.join(extensionSrc, 'GEMINI.md'), 'utf-8');
+        const projectPath = path.join(process.cwd(), 'GEMINI.md');
+        const result = appendIfMissing(projectPath, geminiMd);
+        if (result === 'exists') {
+            lines.push(`${c.dim('Instructions already in')} ${c.file(projectPath)}`);
+        }
+        else {
+            lines.push(`${c.success(result === 'created' ? 'Created' : 'Appended to')} ${c.file(projectPath)}`);
+        }
+        lines.push('');
+        lines.push(c.dim('For native extension install (auto-starts MCP server):'));
+        lines.push(c.bold(`  gemini extensions install ${dest}`));
+    }
+    return lines.join('\n');
+}
+function installCodex(options) {
+    const lines = [];
+    const skillSrc = path.join(pluginsDir(), 'codex');
+    // Install skill to ~/.codex/skills/lore/ (or ~/.agents/skills/lore/)
+    const codexSkillsDir = path.join(homeDir(), '.codex', 'skills', 'lore');
+    const agentsSkillsDir = path.join(homeDir(), '.agents', 'skills', 'lore');
+    // Prefer ~/.codex/skills/ if ~/.codex/ exists, otherwise ~/.agents/skills/
+    const codexDir = path.join(homeDir(), '.codex');
+    const targetDir = existsSync(codexDir) ? codexSkillsDir : agentsSkillsDir;
+    copyDir(skillSrc, targetDir);
+    lines.push(`${c.success('Installed')} skill to ${c.file(targetDir)}`);
+    if (options.global) {
+        // Add instructions to global AGENTS.md
+        const content = readFileSync(path.join(skillSrc, 'SKILL.md'), 'utf-8');
+        const body = content.replace(/^---[\s\S]*?---\n*/, '');
+        const globalPath = path.join(homeDir(), '.codex', 'AGENTS.md');
+        const result = appendIfMissing(globalPath, body);
+        if (result === 'exists') {
+            lines.push(`${c.dim('Instructions already in')} ${c.file(globalPath)}`);
+        }
+        else {
+            lines.push(`${c.success(result === 'created' ? 'Created' : 'Appended to')} ${c.file(globalPath)}`);
+        }
+    }
+    else {
+        // Add instructions to project AGENTS.md
+        const content = readFileSync(path.join(skillSrc, 'SKILL.md'), 'utf-8');
+        const body = content.replace(/^---[\s\S]*?---\n*/, '');
+        const projectPath = path.join(process.cwd(), 'AGENTS.md');
+        const result = appendIfMissing(projectPath, body);
+        if (result === 'exists') {
+            lines.push(`${c.dim('Instructions already in')} ${c.file(projectPath)}`);
+        }
+        else {
+            lines.push(`${c.success(result === 'created' ? 'Created' : 'Appended to')} ${c.file(projectPath)}`);
+        }
+    }
+    lines.push('');
+    lines.push(c.dim('Restart Codex to pick up the new skill.'));
+    lines.push(c.dim('Configure MCP server in Codex:'));
+    lines.push(c.bold('  codex mcp add lore -- npx -y @getlore/cli mcp'));
+    return lines.join('\n');
+}
+function installOpenClaw() {
+    const lines = [];
+    const content = readFileSync(path.join(skillsDir(), 'openclaw.md'), 'utf-8');
+    const skillDir = path.join(homeDir(), '.openclaw', 'skills', 'lore');
+    const skillPath = path.join(skillDir, 'SKILL.md');
+    mkdirSync(skillDir, { recursive: true });
+    if (existsSync(skillPath)) {
+        const existing = readFileSync(skillPath, 'utf-8');
+        if (existing.includes('name: lore')) {
+            lines.push(`${c.dim('Already installed at')} ${c.file(skillPath)}`);
+            return lines.join('\n');
+        }
+    }
+    writeFileSync(skillPath, content);
+    lines.push(`${c.success('Created')} ${c.file(skillPath)}`);
+    lines.push(c.dim('OpenClaw will auto-discover this skill.'));
+    return lines.join('\n');
+}
+function showGeneric() {
+    return readFileSync(path.join(skillsDir(), 'generic-agent.md'), 'utf-8');
+}
+// ── Command Registration ────────────────────────────────────────────────
+export function registerSkillsCommand(program) {
+    const skillsCmd = program
+        .command('skills')
+        .description('Install Lore into your AI coding agents');
+    // lore skills list
+    skillsCmd
+        .command('list')
+        .description('List available agent integrations')
+        .action(() => {
+        console.log(`\n${c.title('Available Integrations')}\n`);
+        for (const skill of AVAILABLE_SKILLS) {
+            console.log(`  ${c.bold(skill.name.padEnd(14))} ${c.dim(skill.description)}`);
+        }
+        console.log(`\n${c.dim('Install with: lore skills install <name>')}`);
+        console.log(c.dim('Add --global to install user-wide instead of project-scoped\n'));
+    });
+    // lore skills install <name>
+    skillsCmd
+        .command('install <name>')
+        .description('Install Lore integration for a specific agent platform')
+        .option('-g, --global', 'Install globally instead of to current project')
+        .action((name, options) => {
+        try {
+            let result;
+            switch (name) {
+                case 'claude-code':
+                case 'claude':
+                    result = installClaudeCode(options);
+                    break;
+                case 'gemini':
+                    result = installGemini(options);
+                    break;
+                case 'codex':
+                    result = installCodex(options);
+                    break;
+                case 'openclaw':
+                    result = installOpenClaw();
+                    break;
+                case 'generic':
+                    result = showGeneric();
+                    break;
+                default:
+                    console.error(c.error(`Unknown agent: ${name}`));
+                    console.log(c.dim(`Available: ${AVAILABLE_SKILLS.map((s) => s.name).join(', ')}`));
+                    process.exit(1);
+            }
+            console.log(result);
+        }
+        catch (error) {
+            console.error(c.error(`Failed to install: ${error instanceof Error ? error.message : error}`));
+            process.exit(1);
+        }
+    });
+    // lore skills show <name>
+    skillsCmd
+        .command('show <name>')
+        .description('Print the contents of an integration\'s instruction file')
+        .action((name) => {
+        try {
+            let content;
+            switch (name) {
+                case 'claude-code':
+                case 'claude':
+                    content = readFileSync(path.join(pluginsDir(), 'claude-code', 'skills', 'lore', 'SKILL.md'), 'utf-8');
+                    break;
+                case 'gemini':
+                    content = readFileSync(path.join(pluginsDir(), 'gemini', 'GEMINI.md'), 'utf-8');
+                    break;
+                case 'codex':
+                    content = readFileSync(path.join(pluginsDir(), 'codex', 'SKILL.md'), 'utf-8');
+                    break;
+                case 'openclaw':
+                    content = readFileSync(path.join(skillsDir(), 'openclaw.md'), 'utf-8');
+                    break;
+                case 'generic':
+                    content = readFileSync(path.join(skillsDir(), 'generic-agent.md'), 'utf-8');
+                    break;
+                default:
+                    console.error(c.error(`Unknown agent: ${name}`));
+                    process.exit(1);
+            }
+            console.log(content);
+        }
+        catch (error) {
+            console.error(c.error(`Failed to read: ${error instanceof Error ? error.message : error}`));
+            process.exit(1);
+        }
+    });
+}
+/**
+ * Interactive skill installation — used by the setup wizard.
+ * Returns a summary of what was installed.
+ */
+export async function interactiveSkillInstall() {
+    const readline = await import('readline');
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+    const ask = (question, defaultValue) => new Promise((resolve) => {
+        const display = defaultValue ? `${question} [${defaultValue}]: ` : `${question}: `;
+        rl.question(display, (answer) => resolve(answer.trim() || defaultValue || ''));
+    });
+    const installed = [];
+    console.log(c.dim('Which AI coding agents do you use? Lore will configure the MCP server'));
+    console.log(c.dim('and install instructions so agents know how to use your knowledge base.\n'));
+    console.log(`  ${c.bold('1.')} Claude Code  ${c.dim('— plugin with MCP auto-start')}`);
+    console.log(`  ${c.bold('2.')} Gemini CLI   ${c.dim('— extension with MCP auto-start')}`);
+    console.log(`  ${c.bold('3.')} Codex CLI    ${c.dim('— skill + MCP config')}`);
+    console.log(`  ${c.bold('4.')} OpenClaw     ${c.dim('— SKILL.md auto-discovery')}`);
+    console.log(`  ${c.bold('5.')} All`);
+    console.log(`  ${c.bold('6.')} Skip\n`);
+    const choice = await ask('Choose (comma-separated for multiple, e.g. 1,2)', '1');
+    rl.close();
+    const choices = choice.split(',').map((s) => s.trim().toLowerCase());
+    if (choices.includes('6') || choices.includes('skip')) {
+        return installed;
+    }
+    const all = choices.includes('5') || choices.includes('all');
+    if (all || choices.includes('1') || choices.includes('claude-code') || choices.includes('claude')) {
+        try {
+            console.log('');
+            console.log(c.bold('Claude Code:'));
+            console.log(installClaudeCode({ global: false }));
+            installed.push('claude-code');
+        }
+        catch (error) {
+            console.log(c.warning(`Claude Code: ${error instanceof Error ? error.message : error}`));
+        }
+    }
+    if (all || choices.includes('2') || choices.includes('gemini')) {
+        try {
+            console.log('');
+            console.log(c.bold('Gemini CLI:'));
+            console.log(installGemini({ global: false }));
+            installed.push('gemini');
+        }
+        catch (error) {
+            console.log(c.warning(`Gemini: ${error instanceof Error ? error.message : error}`));
+        }
+    }
+    if (all || choices.includes('3') || choices.includes('codex')) {
+        try {
+            console.log('');
+            console.log(c.bold('Codex CLI:'));
+            console.log(installCodex({ global: false }));
+            installed.push('codex');
+        }
+        catch (error) {
+            console.log(c.warning(`Codex: ${error instanceof Error ? error.message : error}`));
+        }
+    }
+    if (all || choices.includes('4') || choices.includes('openclaw')) {
+        try {
+            console.log('');
+            console.log(c.bold('OpenClaw:'));
+            console.log(installOpenClaw());
+            installed.push('openclaw');
+        }
+        catch (error) {
+            console.log(c.warning(`OpenClaw: ${error instanceof Error ? error.message : error}`));
+        }
+    }
+    return installed;
+}

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

@@ -0,0 +1,7 @@
+/**
+ * Sources Command
+ *
+ * Manage sync source directories.
+ */
+import type { Command } from 'commander';
+export declare function registerSourcesCommand(program: Command): void;

package/dist/cli/commands/sources.js

@@ -0,0 +1,121 @@
+/**
+ * Sources Command
+ *
+ * Manage sync source directories.
+ */
+export function registerSourcesCommand(program) {
+    const sourcesCmd = program
+        .command('sources')
+        .description('Manage sync source directories');
+    sourcesCmd
+        .command('list')
+        .description('List configured sync sources')
+        .action(async () => {
+        const { loadSyncConfig, getConfigPath } = await import('../../sync/config.js');
+        console.log(`\nSync Sources`);
+        console.log(`============`);
+        console.log(`Config: ${getConfigPath()}\n`);
+        const config = await loadSyncConfig();
+        if (config.sources.length === 0) {
+            console.log('No sources configured. Run "lore sources add" to add one.');
+            return;
+        }
+        for (const source of config.sources) {
+            const status = source.enabled ? '✓' : '○';
+            console.log(`${status} ${source.name}`);
+            console.log(`    Path: ${source.path}`);
+            console.log(`    Glob: ${source.glob}`);
+            console.log(`    Project: ${source.project}`);
+            console.log('');
+        }
+    });
+    sourcesCmd
+        .command('add')
+        .description('Add a new sync source')
+        .option('-n, --name <name>', 'Source name')
+        .option('-p, --path <path>', 'Directory path')
+        .option('-g, --glob <glob>', 'File glob pattern', '**/*.md')
+        .option('--project <project>', 'Default project')
+        .action(async (options) => {
+        const { addSyncSource } = await import('../../sync/config.js');
+        const readline = await import('readline');
+        const rl = readline.createInterface({
+            input: process.stdin,
+            output: process.stdout,
+        });
+        const ask = (question, defaultValue) => new Promise((resolve) => {
+            const prompt = defaultValue ? `${question} [${defaultValue}]: ` : `${question}: `;
+            rl.question(prompt, (answer) => {
+                resolve(answer.trim() || defaultValue || '');
+            });
+        });
+        console.log(`\nAdd Sync Source`);
+        console.log(`===============\n`);
+        const name = options.name || await ask('Name (e.g., "Granola Meetings")');
+        const sourcePath = options.path || await ask('Path (e.g., ~/granola-extractor/output)');
+        const glob = options.glob || await ask('Glob pattern', '**/*.md');
+        const project = options.project || await ask('Default project');
+        rl.close();
+        if (!name || !sourcePath || !project) {
+            console.log('\nAll fields are required.');
+            process.exit(1);
+        }
+        try {
+            await addSyncSource({
+                name,
+                path: sourcePath,
+                glob,
+                project,
+                enabled: true,
+            });
+            console.log(`\n✓ Added source "${name}"`);
+            console.log(`\nRun "lore sync" to process files from this source.`);
+        }
+        catch (error) {
+            console.error(`\nError: ${error}`);
+            process.exit(1);
+        }
+    });
+    sourcesCmd
+        .command('enable <name>')
+        .description('Enable a sync source')
+        .action(async (name) => {
+        const { updateSyncSource } = await import('../../sync/config.js');
+        try {
+            await updateSyncSource(name, { enabled: true });
+            console.log(`✓ Enabled "${name}"`);
+        }
+        catch (error) {
+            console.error(`Error: ${error}`);
+            process.exit(1);
+        }
+    });
+    sourcesCmd
+        .command('disable <name>')
+        .description('Disable a sync source')
+        .action(async (name) => {
+        const { updateSyncSource } = await import('../../sync/config.js');
+        try {
+            await updateSyncSource(name, { enabled: false });
+            console.log(`✓ Disabled "${name}"`);
+        }
+        catch (error) {
+            console.error(`Error: ${error}`);
+            process.exit(1);
+        }
+    });
+    sourcesCmd
+        .command('remove <name>')
+        .description('Remove a sync source')
+        .action(async (name) => {
+        const { removeSyncSource } = await import('../../sync/config.js');
+        try {
+            await removeSyncSource(name);
+            console.log(`✓ Removed "${name}"`);
+        }
+        catch (error) {
+            console.error(`Error: ${error}`);
+            process.exit(1);
+        }
+    });
+}

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

@@ -0,0 +1,31 @@
+/**
+ * Sync Command
+ *
+ * All sync-related functionality: one-time sync, daemon, watch, sources.
+ */
+import type { Command } from 'commander';
+declare const CONFIG_DIR: string;
+declare const PID_FILE: string;
+declare const STATUS_FILE: string;
+declare const LOG_FILE: string;
+export interface DaemonStatus {
+    pid: number;
+    started_at: string;
+    last_sync?: string;
+    last_sync_result?: {
+        files_scanned: number;
+        files_processed: number;
+        errors: number;
+    };
+}
+export declare function registerSyncCommand(program: Command, defaultDataDir: string): void;
+/**
+ * Start the background sync daemon process.
+ * Returns { pid } on success, null on failure.
+ * If already running, returns the existing PID.
+ */
+export declare function startDaemonProcess(dataDir: string): Promise<{
+    pid: number;
+    alreadyRunning: boolean;
+} | null>;
+export { CONFIG_DIR, PID_FILE, STATUS_FILE, LOG_FILE };