@blockrun/franklin 3.2.4 → 3.3.1

package/dist/commands/migrate.js

@@ -0,0 +1,389 @@
+/**
+ * franklin migrate — one-click import from other AI coding agents.
+ *
+ * Detects installed tools (Claude Code, Cline, Cursor, etc.),
+ * shows what can be migrated, and imports with user confirmation.
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+import readline from 'node:readline';
+import chalk from 'chalk';
+import { BLOCKRUN_DIR } from '../config.js';
+function detectSources() {
+    const sources = [];
+    const home = os.homedir();
+    // ── Claude Code ──
+    const claudeDir = path.join(home, '.claude');
+    if (fs.existsSync(claudeDir)) {
+        const items = [];
+        // MCP servers
+        const claudeMcp = path.join(claudeDir, 'mcp.json');
+        if (fs.existsSync(claudeMcp)) {
+            items.push({
+                label: 'MCP servers',
+                source: claudeMcp,
+                target: path.join(BLOCKRUN_DIR, 'mcp.json'),
+                size: fileSize(claudeMcp),
+                transform: () => migrateMcp(claudeMcp),
+            });
+        }
+        // Global instructions → learnings
+        const claudeMd = path.join(claudeDir, 'CLAUDE.md');
+        if (fs.existsSync(claudeMd)) {
+            items.push({
+                label: 'Global instructions (CLAUDE.md)',
+                source: claudeMd,
+                target: path.join(BLOCKRUN_DIR, 'learnings.jsonl'),
+                size: fileSize(claudeMd),
+                transform: () => migrateInstructions(claudeMd),
+            });
+        }
+        // Session history
+        const claudeHistory = path.join(claudeDir, 'history.jsonl');
+        if (fs.existsSync(claudeHistory)) {
+            const lines = countLines(claudeHistory);
+            items.push({
+                label: `Session history (${lines.toLocaleString()} messages)`,
+                source: claudeHistory,
+                target: path.join(BLOCKRUN_DIR, 'sessions'),
+                size: fileSize(claudeHistory),
+                transform: () => migrateSessions(claudeHistory),
+            });
+        }
+        // Project memory files
+        const projectsDir = path.join(claudeDir, 'projects');
+        if (fs.existsSync(projectsDir)) {
+            const memoryFiles = findMemoryFiles(projectsDir);
+            if (memoryFiles.length > 0) {
+                items.push({
+                    label: `Project memories (${memoryFiles.length} files)`,
+                    source: projectsDir,
+                    target: path.join(BLOCKRUN_DIR, 'learnings.jsonl'),
+                    size: `${memoryFiles.length} files`,
+                    transform: () => migrateMemories(memoryFiles),
+                });
+            }
+        }
+        if (items.length > 0) {
+            sources.push({ name: 'Claude Code', dir: claudeDir, items });
+        }
+    }
+    // ── Cline / OpenClaw ──
+    const clineDir = path.join(home, 'Library', 'Application Support', 'Code', 'User', 'globalStorage', 'saoudrizwan.claude-dev');
+    if (fs.existsSync(clineDir)) {
+        const items = [];
+        // TODO: detect Cline data
+        if (items.length > 0) {
+            sources.push({ name: 'Cline', dir: clineDir, items });
+        }
+    }
+    // ── Cursor ──
+    const cursorDir = path.join(home, 'Library', 'Application Support', 'Cursor');
+    if (fs.existsSync(cursorDir)) {
+        const items = [];
+        // TODO: detect Cursor data
+        if (items.length > 0) {
+            sources.push({ name: 'Cursor', dir: cursorDir, items });
+        }
+    }
+    return sources;
+}
+// ─── Transforms ───────────────────────────────────────────────────────────
+function migrateMcp(source) {
+    const target = path.join(BLOCKRUN_DIR, 'mcp.json');
+    const raw = JSON.parse(fs.readFileSync(source, 'utf-8'));
+    // Claude Code format: { mcpServers: { name: { command, args, env } } }
+    // Franklin format:    { mcpServers: { name: { transport, command, args, label } } }
+    const servers = {};
+    if (raw.mcpServers) {
+        for (const [name, config] of Object.entries(raw.mcpServers)) {
+            servers[name] = {
+                transport: config.transport || 'stdio',
+                command: config.command,
+                args: config.args || [],
+                label: name,
+                ...(config.env ? { env: config.env } : {}),
+            };
+        }
+    }
+    // Merge with existing Franklin MCP config
+    let existing = {};
+    try {
+        if (fs.existsSync(target)) {
+            existing = JSON.parse(fs.readFileSync(target, 'utf-8'));
+        }
+    }
+    catch { /* start fresh */ }
+    const merged = {
+        mcpServers: {
+            ...(existing.mcpServers || {}),
+            ...servers,
+        },
+    };
+    fs.mkdirSync(BLOCKRUN_DIR, { recursive: true });
+    fs.writeFileSync(target, JSON.stringify(merged, null, 2));
+    console.log(chalk.green(`    ✓ ${Object.keys(servers).length} MCP server(s) imported`));
+}
+function migrateInstructions(source) {
+    // Read CLAUDE.md and convert key preferences to learnings
+    const content = fs.readFileSync(source, 'utf-8');
+    const learningsPath = path.join(BLOCKRUN_DIR, 'learnings.jsonl');
+    // Extract simple preference lines as learnings
+    const lines = content.split('\n');
+    const learnings = [];
+    const now = Date.now();
+    let count = 0;
+    for (const line of lines) {
+        const trimmed = line.trim();
+        // Skip empty lines, headers, and code blocks
+        if (!trimmed || trimmed.startsWith('#') || trimmed.startsWith('```') || trimmed.startsWith('|'))
+            continue;
+        // Skip very short or very long lines
+        if (trimmed.length < 15 || trimmed.length > 200)
+            continue;
+        // Skip lines that are just paths or URLs
+        if (trimmed.startsWith('/') || trimmed.startsWith('http'))
+            continue;
+        // Lines starting with - or * are likely preference rules
+        if (trimmed.startsWith('- ') || trimmed.startsWith('* ')) {
+            const text = trimmed.slice(2).trim();
+            if (text.length > 15) {
+                const entry = {
+                    id: `migrate-${count++}`,
+                    learning: text.slice(0, 200),
+                    category: 'other',
+                    confidence: 0.8,
+                    source_session: 'migrate:claude-code',
+                    created_at: now,
+                    last_confirmed: now,
+                    times_confirmed: 1,
+                };
+                learnings.push(JSON.stringify(entry));
+            }
+        }
+    }
+    if (learnings.length > 0) {
+        fs.mkdirSync(BLOCKRUN_DIR, { recursive: true });
+        // Append to existing learnings
+        fs.appendFileSync(learningsPath, learnings.join('\n') + '\n');
+        console.log(chalk.green(`    ✓ ${learnings.length} preferences imported`));
+    }
+    else {
+        console.log(chalk.dim('    ○ No extractable preferences found'));
+    }
+}
+function migrateSessions(source) {
+    const sessionsDir = path.join(BLOCKRUN_DIR, 'sessions');
+    fs.mkdirSync(sessionsDir, { recursive: true });
+    const raw = fs.readFileSync(source, 'utf-8');
+    const lines = raw.split('\n').filter(l => l.trim());
+    // Group by conversation turns — each user+assistant pair is a chunk
+    // We'll create session files grouped by day
+    const sessions = new Map();
+    for (const line of lines) {
+        try {
+            const msg = JSON.parse(line);
+            // Use date from the line or current date as session key
+            const dateKey = new Date().toISOString().split('T')[0];
+            // Try to extract timestamp if present
+            const ts = msg.timestamp || msg.created_at || msg.ts;
+            const key = ts ? new Date(ts).toISOString().split('T')[0] : dateKey;
+            if (!sessions.has(key))
+                sessions.set(key, []);
+            sessions.get(key).push(line);
+        }
+        catch {
+            // Skip unparseable lines
+        }
+    }
+    let imported = 0;
+    for (const [dateKey, msgs] of sessions) {
+        const sessionId = `imported-${dateKey}`;
+        const sessionFile = path.join(sessionsDir, `${sessionId}.jsonl`);
+        // Don't overwrite existing imported sessions
+        if (fs.existsSync(sessionFile))
+            continue;
+        fs.writeFileSync(sessionFile, msgs.join('\n') + '\n');
+        // Create metadata
+        const meta = {
+            id: sessionId,
+            model: 'imported',
+            workDir: os.homedir(),
+            createdAt: new Date(dateKey).getTime(),
+            updatedAt: Date.now(),
+            turnCount: Math.floor(msgs.length / 2),
+            messageCount: msgs.length,
+        };
+        fs.writeFileSync(path.join(sessionsDir, `${sessionId}.meta.json`), JSON.stringify(meta, null, 2));
+        imported++;
+    }
+    console.log(chalk.green(`    ✓ ${lines.length.toLocaleString()} messages → ${imported} session(s)`));
+}
+function migrateMemories(files) {
+    const learningsPath = path.join(BLOCKRUN_DIR, 'learnings.jsonl');
+    const now = Date.now();
+    let count = 0;
+    const entries = [];
+    for (const file of files) {
+        try {
+            const content = fs.readFileSync(file, 'utf-8');
+            const lines = content.split('\n');
+            for (const line of lines) {
+                const trimmed = line.trim();
+                if (!trimmed || trimmed.startsWith('#') || trimmed.startsWith('```'))
+                    continue;
+                if (trimmed.startsWith('- ') && trimmed.length > 20 && trimmed.length < 200) {
+                    const text = trimmed.slice(2).trim();
+                    // Skip index entries (links to other files)
+                    if (text.startsWith('[') && text.includes(']('))
+                        continue;
+                    entries.push(JSON.stringify({
+                        id: `memory-${count++}`,
+                        learning: text.slice(0, 200),
+                        category: 'other',
+                        confidence: 0.7,
+                        source_session: 'migrate:project-memory',
+                        created_at: now,
+                        last_confirmed: now,
+                        times_confirmed: 1,
+                    }));
+                }
+            }
+        }
+        catch { /* skip unreadable files */ }
+    }
+    if (entries.length > 0) {
+        fs.mkdirSync(BLOCKRUN_DIR, { recursive: true });
+        fs.appendFileSync(learningsPath, entries.join('\n') + '\n');
+        console.log(chalk.green(`    ✓ ${entries.length} memories imported`));
+    }
+    else {
+        console.log(chalk.dim('    ○ No extractable memories found'));
+    }
+}
+// ─── Helpers ──────────────────────────────────────────────────────────────
+function fileSize(p) {
+    try {
+        const bytes = fs.statSync(p).size;
+        if (bytes < 1024)
+            return `${bytes} B`;
+        if (bytes < 1024 * 1024)
+            return `${(bytes / 1024).toFixed(1)} KB`;
+        return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+    }
+    catch {
+        return '?';
+    }
+}
+function countLines(p) {
+    try {
+        return fs.readFileSync(p, 'utf-8').split('\n').filter(l => l.trim()).length;
+    }
+    catch {
+        return 0;
+    }
+}
+function findMemoryFiles(projectsDir) {
+    const files = [];
+    try {
+        for (const project of fs.readdirSync(projectsDir)) {
+            const memoryDir = path.join(projectsDir, project, 'memory');
+            if (!fs.existsSync(memoryDir))
+                continue;
+            for (const file of fs.readdirSync(memoryDir)) {
+                if (file.endsWith('.md') && file !== 'MEMORY.md') {
+                    files.push(path.join(memoryDir, file));
+                }
+            }
+        }
+    }
+    catch { /* ignore */ }
+    return files;
+}
+// ─── Interactive prompt ───────────────────────────────────────────────────
+function ask(question) {
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    return new Promise(resolve => {
+        rl.question(question, answer => { rl.close(); resolve(answer.trim().toLowerCase()); });
+    });
+}
+// ─── Main command ─────────────────────────────────────────────────────────
+export async function migrateCommand() {
+    console.log(chalk.bold('\n  franklin migrate\n'));
+    const sources = detectSources();
+    if (sources.length === 0) {
+        console.log(chalk.dim('  No other AI tools detected. Nothing to migrate.\n'));
+        console.log(chalk.dim('  Supported: Claude Code, Cline, Cursor\n'));
+        return;
+    }
+    // Show what was found
+    for (const source of sources) {
+        console.log(chalk.bold(`  ${chalk.green('●')} ${source.name}`) + chalk.dim(` (${source.dir})`));
+        for (const item of source.items) {
+            console.log(chalk.dim(`    ├─ ${item.label}`) + (item.size ? chalk.dim(` [${item.size}]`) : ''));
+        }
+        console.log('');
+    }
+    const total = sources.reduce((n, s) => n + s.items.length, 0);
+    const answer = await ask(chalk.yellow(`  Import ${total} item(s) into Franklin? [Y/n] `));
+    if (answer && answer !== 'y' && answer !== 'yes') {
+        console.log(chalk.dim('\n  Cancelled.\n'));
+        return;
+    }
+    console.log('');
+    // Run migrations
+    for (const source of sources) {
+        console.log(chalk.bold(`  Migrating from ${source.name}...`));
+        for (const item of source.items) {
+            try {
+                item.transform();
+            }
+            catch (err) {
+                console.log(chalk.red(`    ✗ ${item.label}: ${err.message}`));
+            }
+        }
+        console.log('');
+    }
+    console.log(chalk.green('  Done.') + chalk.dim(' Run `franklin --trust` to start.\n'));
+}
+// ─── First-run detection (called from start.ts) ──────────────────────────
+const MIGRATED_MARKER = path.join(BLOCKRUN_DIR, '.migrated');
+/**
+ * Check if other AI tools are installed and suggest migration.
+ * Only runs once — writes a marker file after first check.
+ * Returns true if the user chose to migrate (caller should re-run start after).
+ */
+export async function checkAndSuggestMigration() {
+    // Only suggest once
+    if (fs.existsSync(MIGRATED_MARKER))
+        return false;
+    // Write marker immediately so we never ask again
+    fs.mkdirSync(BLOCKRUN_DIR, { recursive: true });
+    fs.writeFileSync(MIGRATED_MARKER, new Date().toISOString());
+    const sources = detectSources();
+    if (sources.length === 0)
+        return false;
+    const names = sources.map(s => s.name).join(', ');
+    const total = sources.reduce((n, s) => n + s.items.length, 0);
+    console.log(chalk.bold(`\n  ${chalk.green('●')} Found ${names} — ${total} items available to import.`));
+    const answer = await ask(chalk.yellow(`  Import into Franklin? [Y/n] `));
+    if (answer && answer !== 'y' && answer !== 'yes') {
+        console.log(chalk.dim('  Skipped. Run `franklin migrate` anytime.\n'));
+        return false;
+    }
+    console.log('');
+    for (const source of sources) {
+        console.log(chalk.bold(`  Migrating from ${source.name}...`));
+        for (const item of source.items) {
+            try {
+                item.transform();
+            }
+            catch (err) {
+                console.log(chalk.red(`    ✗ ${item.label}: ${err.message}`));
+            }
+        }
+    }
+    console.log(chalk.green('\n  Done.') + ' Starting Franklin...\n');
+    return true;
+}

package/dist/commands/panel.d.ts

@@ -0,0 +1,6 @@
+/**
+ * franklin panel — launch the local web dashboard.
+ */
+export declare function panelCommand(options: {
+    port?: string;
+}): Promise<void>;

package/dist/commands/panel.js

@@ -0,0 +1,29 @@
+/**
+ * franklin panel — launch the local web dashboard.
+ */
+import chalk from 'chalk';
+import { createPanelServer } from '../panel/server.js';
+export async function panelCommand(options) {
+    const port = parseInt(options.port || '3100', 10);
+    const server = createPanelServer(port);
+    server.listen(port, () => {
+        console.log('');
+        console.log(chalk.bold('  Franklin Panel'));
+        console.log(chalk.dim(`  http://localhost:${port}`));
+        console.log('');
+        console.log(chalk.dim('  Press Ctrl+C to stop.'));
+        console.log('');
+        // Try to open browser
+        const open = process.platform === 'darwin' ? 'open' : process.platform === 'win32' ? 'start' : 'xdg-open';
+        import('node:child_process').then(({ exec }) => {
+            exec(`${open} http://localhost:${port}`);
+        }).catch(() => { });
+    });
+    // Graceful shutdown
+    const shutdown = () => {
+        server.close();
+        process.exit(0);
+    };
+    process.on('SIGINT', shutdown);
+    process.on('SIGTERM', shutdown);
+}

package/dist/commands/start.js

@@ -50,16 +50,33 @@ export async function startCommand(options) {
             console.log(chalk.dim('  Free models work now. Fund with USDC for paid models.\n'));
         }
     }
+    // First-run: detect other AI tools and offer migration
+    if (process.stdin.isTTY) {
+        try {
+            const { checkAndSuggestMigration } = await import('./migrate.js');
+            await checkAndSuggestMigration();
+        }
+        catch { /* migration is optional */ }
+    }
     printBanner(version);
     const workDir = process.cwd();
     // Show session info immediately, fetch balance in background
-    console.log(chalk.dim(`  Model:  ${model}`));
+    // Model is shown in the live status bar — no static line needed.
     console.log(chalk.dim(`  Wallet: ${walletAddress || 'not set'}`));
     console.log(chalk.dim(`  Dir:    ${workDir}`));
     // First-run tip: show if no config file exists yet
     if (!configModel && !options.model) {
         console.log(chalk.dim(`\n  Tip: /model to switch models · /compact to save tokens · /help for all commands`));
     }
+    // Welcome message — show things Hermes/OpenClaw can't do.
+    // Only on first run or when no model is configured (new user indicator).
+    // After the user's first session, the tip fades and they go straight to the prompt.
+    console.log('');
+    console.log(chalk.dim('  Try something only Franklin can do:'));
+    console.log(chalk.dim('    ') + chalk.hex('#FFD700')('"what\'s BTC looking like today?"') + chalk.dim('  ← market signal'));
+    console.log(chalk.dim('    ') + chalk.hex('#10B981')('"find X posts about ai agent"') + chalk.dim('  ← social growth'));
+    console.log(chalk.dim('    ') + chalk.hex('#60A5FA')('"generate a hero image for my app"') + chalk.dim('  ← image gen'));
+    console.log(chalk.dim('  Or just code — 55+ models, no API keys.'));
     console.log('');
     // Balance fetcher — used at startup and after each turn
     const fetchBalance = async () => {
@@ -130,6 +147,14 @@ export async function startCommand(options) {
         permissionMode: (options.trust || !process.stdin.isTTY) ? 'trust' : 'default',
         debug: options.debug,
     };
+    // Bootstrap learnings from Claude Code config on first run (async, non-blocking)
+    Promise.all([
+        import('../learnings/extractor.js'),
+        import('../agent/llm.js'),
+    ]).then(([{ bootstrapFromClaudeConfig }, { ModelClient }]) => {
+        const client = new ModelClient({ apiUrl, chain });
+        bootstrapFromClaudeConfig(client).catch(() => { });
+    }).catch(() => { });
     // Use Ink UI if TTY, fallback to basic readline for piped input
     if (process.stdin.isTTY) {
         await runWithInkUI(agentConfig, model, workDir, version, walletInfo, (cb) => {
@@ -167,8 +192,9 @@ async function runWithInkUI(agentConfig, model, workDir, version, walletInfo, on
             fetchBalance().then(bal => ui.updateBalance(bal)).catch(() => { });
         });
     }
+    let sessionHistory;
     try {
-        await interactiveSession(agentConfig, async () => {
+        sessionHistory = await interactiveSession(agentConfig, async () => {
             const input = await ui.waitForInput();
             if (input === null)
                 return null;
@@ -184,6 +210,19 @@ async function runWithInkUI(agentConfig, model, workDir, version, walletInfo, on
     }
     ui.cleanup();
     flushStats();
+    // Extract learnings from the session (async, 10s timeout, never blocks exit)
+    if (sessionHistory && sessionHistory.length >= 4) {
+        try {
+            const { extractLearnings } = await import('../learnings/extractor.js');
+            const { ModelClient } = await import('../agent/llm.js');
+            const client = new ModelClient({ apiUrl: agentConfig.apiUrl, chain: agentConfig.chain });
+            await Promise.race([
+                extractLearnings(sessionHistory, `session-${new Date().toISOString()}`, client),
+                new Promise(resolve => setTimeout(resolve, 10_000)),
+            ]);
+        }
+        catch { /* extraction is best-effort */ }
+    }
     await disconnectMcpServers();
     console.log(chalk.dim('\nGoodbye.\n'));
 }

package/dist/events/bridge.d.ts

@@ -0,0 +1 @@
+export declare function initBridge(): void;

package/dist/events/bridge.js

@@ -0,0 +1,24 @@
+import { bus } from './bus.js';
+import { addSignal, addPost } from '../narrative/state.js';
+export function initBridge() {
+    bus.on('signal.detected', (event) => {
+        const e = event;
+        addSignal({
+            asset: e.data.asset,
+            direction: e.data.direction,
+            confidence: e.data.confidence,
+            summary: e.data.summary,
+            ts: e.ts,
+        });
+    });
+    bus.on('post.published', (event) => {
+        const e = event;
+        addPost({
+            platform: e.data.platform,
+            url: e.data.url,
+            text: e.data.text,
+            referencesAssets: e.data.referencesAssets,
+            ts: e.ts,
+        });
+    });
+}

package/dist/events/bus.d.ts

@@ -0,0 +1,17 @@
+import type { FranklinEvent } from './types.js';
+type Handler = (event: FranklinEvent) => void | Promise<void>;
+export declare class EventBus {
+    private handlers;
+    private logEnabled;
+    private logPath;
+    constructor(opts?: {
+        log?: boolean;
+    });
+    on(type: FranklinEvent['type'], handler: Handler): void;
+    off(type: FranklinEvent['type'], handler: Handler): void;
+    emit(event: FranklinEvent): Promise<void>;
+    clear(): void;
+    private appendLog;
+}
+export declare const bus: EventBus;
+export {};

package/dist/events/bus.js

@@ -0,0 +1,55 @@
+import os from 'node:os';
+import path from 'node:path';
+import fs from 'node:fs';
+export class EventBus {
+    handlers = new Map();
+    logEnabled;
+    logPath;
+    constructor(opts = {}) {
+        this.logEnabled = opts.log ?? false;
+        this.logPath = path.join(os.homedir(), '.blockrun', 'events.jsonl');
+    }
+    on(type, handler) {
+        let set = this.handlers.get(type);
+        if (!set) {
+            set = new Set();
+            this.handlers.set(type, set);
+        }
+        set.add(handler);
+    }
+    off(type, handler) {
+        this.handlers.get(type)?.delete(handler);
+    }
+    async emit(event) {
+        if (this.logEnabled) {
+            this.appendLog(event);
+        }
+        const set = this.handlers.get(event.type);
+        if (!set)
+            return;
+        const promises = [];
+        for (const handler of set) {
+            const result = handler(event);
+            if (result)
+                promises.push(result);
+        }
+        if (promises.length)
+            await Promise.all(promises);
+    }
+    clear() {
+        this.handlers.clear();
+    }
+    appendLog(event) {
+        try {
+            const dir = path.dirname(this.logPath);
+            if (!fs.existsSync(dir)) {
+                fs.mkdirSync(dir, { recursive: true });
+            }
+            fs.appendFileSync(this.logPath, JSON.stringify(event) + '\n');
+        }
+        catch {
+            // best-effort logging — don't crash the agent
+        }
+    }
+}
+export const bus = new EventBus();

package/dist/events/types.d.ts

@@ -0,0 +1,49 @@
+export interface BaseEvent {
+    id: string;
+    type: string;
+    ts: string;
+    source: 'trading' | 'social' | 'core';
+    costUsd?: number;
+    correlationId?: string;
+}
+export interface SignalDetectedEvent extends BaseEvent {
+    type: 'signal.detected';
+    data: {
+        asset: string;
+        direction: 'bullish' | 'bearish' | 'neutral';
+        confidence: number;
+        indicators: Record<string, number>;
+        summary: string;
+    };
+}
+export interface PostPublishedEvent extends BaseEvent {
+    type: 'post.published';
+    data: {
+        platform: 'x' | 'reddit' | (string & {});
+        url: string;
+        text: string;
+        referencesAssets?: string[];
+    };
+}
+export interface MentionReceivedEvent extends BaseEvent {
+    type: 'mention.received';
+    data: {
+        platform: string;
+        url: string;
+        text: string;
+        author: string;
+        sentiment?: 'positive' | 'negative' | 'neutral';
+        mentionsAsset?: string;
+    };
+}
+export interface BudgetExceededEvent extends BaseEvent {
+    type: 'budget.exceeded';
+    data: {
+        category: 'llm' | 'data' | 'gas';
+        spent: number;
+        cap: number;
+        blockedAction: string;
+    };
+}
+export type FranklinEvent = SignalDetectedEvent | PostPublishedEvent | MentionReceivedEvent | BudgetExceededEvent;
+export declare function makeEvent<T extends FranklinEvent>(props: Omit<T, 'id' | 'ts'>): T;

package/dist/events/types.js

@@ -0,0 +1,8 @@
+import crypto from 'node:crypto';
+export function makeEvent(props) {
+    return {
+        id: crypto.randomUUID(),
+        ts: new Date().toISOString(),
+        ...props,
+    };
+}