beecork 1.6.0 → 1.7.1

package/dist/cron/scheduler.d.ts

@@ -0,0 +1,22 @@
+import type { TabManager, NotifyCallback } from '../session/manager.js';
+export declare class CronScheduler {
+    private tabManager;
+    private onNotify;
+    private scheduledJobs;
+    private store;
+    constructor(tabManager: TabManager, onNotify: NotifyCallback | null);
+    /** Load all cron jobs from store and schedule them */
+    loadAndSchedule(): void;
+    /** Check for the reload signal file and reload if present */
+    checkForReload(): void;
+    /** Stop all scheduled jobs */
+    stopAll(): void;
+    private scheduleJob;
+    private fireJob;
+    private handleSystemEvent;
+}
+/** Convert human interval (30m, 2h, 1d, 1h30m, 2w) to milliseconds */
+export declare function intervalToMs(interval: string): number | null;
+/** Convert human interval (30m, 2h, 1d, 1h30m, 2w) to cron expression */
+export declare function intervalToCron(interval: string): string | null;
+//# sourceMappingURL=scheduler.d.ts.map

package/dist/cron/scheduler.js

@@ -0,0 +1,220 @@
+import cron from 'node-cron';
+import fs from 'node:fs';
+import path from 'node:path';
+import { CronStore } from './store.js';
+import { getCronReloadSignalPath, getLogsDir } from '../util/paths.js';
+import { logger } from '../util/logger.js';
+export class CronScheduler {
+    tabManager;
+    onNotify;
+    scheduledJobs = new Map();
+    store = new CronStore();
+    constructor(tabManager, onNotify) {
+        this.tabManager = tabManager;
+        this.onNotify = onNotify;
+    }
+    /** Load all cron jobs from store and schedule them */
+    loadAndSchedule() {
+        // Cancel existing
+        for (const [, task] of this.scheduledJobs) {
+            task.stop();
+        }
+        this.scheduledJobs.clear();
+        const jobs = this.store.list();
+        let scheduled = 0;
+        let missedFires = 0;
+        for (const job of jobs) {
+            if (!job.enabled)
+                continue;
+            // Detect missed fires: one-time "at" jobs whose time has passed but never ran
+            if (job.scheduleType === 'at' && !job.lastRunAt) {
+                const targetTime = new Date(job.schedule).getTime();
+                if (targetTime <= Date.now()) {
+                    logger.warn(`Cron: missed fire detected for "${job.name}" (was scheduled for ${job.schedule}), firing now`);
+                    missedFires++;
+                    this.fireJob(job);
+                    this.store.update(job.id, { enabled: false }); // Disable after one-time execution
+                    continue;
+                }
+            }
+            this.scheduleJob(job);
+            scheduled++;
+        }
+        logger.info(`Cron: loaded ${scheduled} active jobs (${jobs.length} total)${missedFires > 0 ? `, fired ${missedFires} missed` : ''}`);
+    }
+    /** Check for the reload signal file and reload if present */
+    checkForReload() {
+        const signalPath = getCronReloadSignalPath();
+        if (fs.existsSync(signalPath)) {
+            try {
+                fs.unlinkSync(signalPath);
+            }
+            catch { /* race condition, ok */ }
+            logger.info('Cron: reload signal detected, reloading schedules');
+            this.loadAndSchedule();
+        }
+    }
+    /** Stop all scheduled jobs */
+    stopAll() {
+        for (const [, task] of this.scheduledJobs) {
+            task.stop();
+        }
+        this.scheduledJobs.clear();
+    }
+    scheduleJob(job) {
+        switch (job.scheduleType) {
+            case 'cron': {
+                if (!cron.validate(job.schedule)) {
+                    logger.error(`Cron: invalid expression for "${job.name}": ${job.schedule}`);
+                    return;
+                }
+                const task = cron.schedule(job.schedule, () => this.fireJob(job));
+                this.scheduledJobs.set(job.id, task);
+                break;
+            }
+            case 'every': {
+                const cronExpr = intervalToCron(job.schedule);
+                if (cronExpr) {
+                    if (!cron.validate(cronExpr)) {
+                        logger.error(`Cron: invalid cron expression for "${job.name}": ${cronExpr}`);
+                        return;
+                    }
+                    const task = cron.schedule(cronExpr, () => this.fireJob(job));
+                    this.scheduledJobs.set(job.id, task);
+                }
+                else {
+                    // Use setInterval for non-cron-expressible intervals
+                    const totalMs = intervalToMs(job.schedule);
+                    if (totalMs) {
+                        const timer = setInterval(() => this.fireJob(job), totalMs);
+                        this.scheduledJobs.set(job.id, { stop: () => clearInterval(timer) });
+                    }
+                    else {
+                        logger.error(`Cron: invalid interval for "${job.name}": ${job.schedule}`);
+                    }
+                }
+                break;
+            }
+            case 'at': {
+                const targetTime = new Date(job.schedule).getTime();
+                const delay = targetTime - Date.now();
+                if (delay <= 0) {
+                    logger.warn(`Cron: one-time job "${job.name}" is in the past, skipping`);
+                    return;
+                }
+                const timer = setTimeout(() => {
+                    this.fireJob(job);
+                    this.store.update(job.id, { enabled: false });
+                }, delay);
+                this.scheduledJobs.set(job.id, { stop: () => clearTimeout(timer) });
+                break;
+            }
+        }
+    }
+    async fireJob(job) {
+        logger.info(`Cron firing: "${job.name}" (${job.payloadType || 'agentTurn'}) → tab:${job.tabName}`);
+        const logFile = path.join(getLogsDir(), `cron-${job.name}.log`);
+        // Handle systemEvent — internal Beecork actions, not Claude Code
+        if (job.payloadType === 'systemEvent') {
+            try {
+                await this.handleSystemEvent(job);
+                this.store.update(job.id, { lastRunAt: new Date().toISOString() });
+                fs.appendFileSync(logFile, `[${new Date().toISOString()}] SYSTEM: ${job.message}\n`);
+            }
+            catch (err) {
+                const errMsg = err instanceof Error ? err.message : String(err);
+                logger.error(`System event "${job.name}" failed:`, err);
+                fs.appendFileSync(logFile, `[${new Date().toISOString()}] ERROR: ${errMsg}\n`);
+            }
+            return;
+        }
+        try {
+            this.tabManager.ensureTab(job.tabName);
+            const result = await this.tabManager.sendMessage(job.tabName, job.message);
+            this.store.update(job.id, { lastRunAt: new Date().toISOString() });
+            const firstLine = result.text.split('\n')[0]?.slice(0, 200) || '(no output)';
+            // Log result
+            fs.appendFileSync(logFile, `[${new Date().toISOString()}] SUCCESS: ${firstLine}\n`);
+            // Notify (separate try/catch — notification failure shouldn't be reported as job failure)
+            try {
+                if (this.onNotify) {
+                    if (result.error) {
+                        await this.onNotify(`❌ [${job.name}] Failed — ${firstLine}`);
+                    }
+                    else {
+                        await this.onNotify(`✅ [${job.name}] Done — ${firstLine}`);
+                    }
+                }
+            }
+            catch (notifyErr) {
+                logger.warn(`Cron job "${job.name}" notification failed:`, notifyErr);
+            }
+        }
+        catch (err) {
+            const errMsg = err instanceof Error ? err.message : String(err);
+            logger.error(`Cron job "${job.name}" failed:`, err);
+            fs.appendFileSync(logFile, `[${new Date().toISOString()}] ERROR: ${errMsg}\n`);
+            try {
+                await this.onNotify?.(`❌ [${job.name}] Failed — ${errMsg}`);
+            }
+            catch { /* notification best-effort */ }
+        }
+    }
+    async handleSystemEvent(job) {
+        switch (job.message) {
+            case 'health_check':
+                logger.info('System event: health check — daemon alive');
+                if (this.onNotify) {
+                    await this.onNotify('🟢 Beecork health check: all systems operational');
+                }
+                break;
+            case 'memory_compaction':
+                logger.info('System event: memory compaction (not yet implemented)');
+                break;
+            default:
+                logger.warn(`Unknown system event: ${job.message}`);
+        }
+    }
+}
+/** Convert human interval (30m, 2h, 1d, 1h30m, 2w) to milliseconds */
+export function intervalToMs(interval) {
+    const match = interval.match(/^(?:(\d+)w)?(?:(\d+)d)?(?:(\d+)h)?(?:(\d+)m)?$/);
+    if (!match || match.slice(1).every(g => g === undefined))
+        return null;
+    const weeks = parseInt(match[1] || '0', 10);
+    const days = parseInt(match[2] || '0', 10);
+    const hours = parseInt(match[3] || '0', 10);
+    const mins = parseInt(match[4] || '0', 10);
+    const totalMs = ((weeks * 7 * 24 * 60) + (days * 24 * 60) + (hours * 60) + mins) * 60 * 1000;
+    return totalMs > 0 ? totalMs : null;
+}
+/** Convert human interval (30m, 2h, 1d, 1h30m, 2w) to cron expression */
+export function intervalToCron(interval) {
+    // Try combined format: 1h30m, 2h, 30m, 1d, 2w
+    const match = interval.match(/^(?:(\d+)w)?(?:(\d+)d)?(?:(\d+)h)?(?:(\d+)m)?$/);
+    if (!match || match.slice(1).every(g => g === undefined))
+        return null;
+    const weeks = parseInt(match[1] || '0', 10);
+    const days = parseInt(match[2] || '0', 10);
+    const hours = parseInt(match[3] || '0', 10);
+    const mins = parseInt(match[4] || '0', 10);
+    // Convert to total minutes for simple intervals
+    const totalMins = weeks * 7 * 24 * 60 + days * 24 * 60 + hours * 60 + mins;
+    if (totalMins <= 0)
+        return null;
+    // Simple minute interval
+    if (totalMins <= 59)
+        return `*/${totalMins} * * * *`;
+    // Hourly intervals
+    if (mins === 0 && days === 0 && weeks === 0 && hours > 0 && hours <= 23)
+        return `0 */${hours} * * *`;
+    // Daily intervals
+    if (mins === 0 && hours === 0 && weeks === 0 && days > 0)
+        return `0 0 */${days} * *`;
+    // Weekly intervals
+    if (mins === 0 && hours === 0 && days === 0 && weeks > 0)
+        return `0 0 * * 0`;
+    // Combined or large intervals — return null, handled by setInterval in scheduleJob
+    return null;
+}
+//# sourceMappingURL=scheduler.js.map

package/dist/cron/store.d.ts

@@ -0,0 +1,12 @@
+import type { CronJob } from '../types.js';
+export declare class CronStore {
+    constructor();
+    list(): CronJob[];
+    get(id: string): CronJob | undefined;
+    add(job: CronJob): void;
+    update(id: string, updates: Partial<CronJob>): boolean;
+    delete(id: string): boolean;
+    /** One-time migration from crontab.json to SQLite */
+    private migrateFromJson;
+}
+//# sourceMappingURL=store.d.ts.map

package/dist/cron/store.js

@@ -0,0 +1,83 @@
+import fs from 'node:fs';
+import { getDb } from '../db/index.js';
+import { getCrontabPath } from '../util/paths.js';
+import { logger } from '../util/logger.js';
+function rowToJob(row) {
+    return {
+        id: row.id, name: row.name,
+        scheduleType: row.schedule_type,
+        schedule: row.schedule, tabName: row.tab_name, message: row.message,
+        payloadType: row.payload_type || 'agentTurn',
+        enabled: row.enabled === 1, createdAt: row.created_at,
+        lastRunAt: row.last_run_at, nextRunAt: row.next_run_at,
+    };
+}
+export class CronStore {
+    constructor() {
+        this.migrateFromJson();
+    }
+    list() {
+        const db = getDb();
+        return db.prepare('SELECT * FROM cron_jobs WHERE user_id = ? ORDER BY created_at').all('local').map(rowToJob);
+    }
+    get(id) {
+        const db = getDb();
+        const row = db.prepare('SELECT * FROM cron_jobs WHERE id = ?').get(id);
+        return row ? rowToJob(row) : undefined;
+    }
+    add(job) {
+        const db = getDb();
+        db.prepare(`INSERT INTO cron_jobs (id, name, schedule_type, schedule, tab_name, message, payload_type, enabled, user_id, created_at, last_run_at, next_run_at)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(job.id, job.name, job.scheduleType, job.schedule, job.tabName, job.message, job.payloadType || 'agentTurn', job.enabled ? 1 : 0, 'local', job.createdAt, job.lastRunAt, job.nextRunAt);
+    }
+    update(id, updates) {
+        const db = getDb();
+        const existing = this.get(id);
+        if (!existing)
+            return false;
+        const merged = { ...existing, ...updates };
+        db.prepare(`UPDATE cron_jobs SET name=?, schedule_type=?, schedule=?, tab_name=?, message=?, enabled=?, last_run_at=?, next_run_at=? WHERE id=?`).run(merged.name, merged.scheduleType, merged.schedule, merged.tabName, merged.message, merged.enabled ? 1 : 0, merged.lastRunAt, merged.nextRunAt, id);
+        return true;
+    }
+    delete(id) {
+        const db = getDb();
+        const result = db.prepare('DELETE FROM cron_jobs WHERE id = ?').run(id);
+        return result.changes > 0;
+    }
+    /** One-time migration from crontab.json to SQLite */
+    migrateFromJson() {
+        const jsonPath = getCrontabPath();
+        if (!fs.existsSync(jsonPath))
+            return;
+        const db = getDb();
+        const count = db.prepare('SELECT COUNT(*) as count FROM cron_jobs').get();
+        if (count.count > 0) {
+            // Already migrated, clean up JSON
+            try {
+                fs.renameSync(jsonPath, jsonPath + '.bak');
+            }
+            catch { /* ok */ }
+            return;
+        }
+        try {
+            const data = JSON.parse(fs.readFileSync(jsonPath, 'utf-8'));
+            const jobs = data.jobs || [];
+            if (jobs.length === 0)
+                return;
+            const insert = db.prepare(`INSERT OR IGNORE INTO cron_jobs (id, name, schedule_type, schedule, tab_name, message, enabled, user_id, created_at, last_run_at, next_run_at)
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`);
+            const tx = db.transaction(() => {
+                for (const j of jobs) {
+                    insert.run(j.id, j.name, j.scheduleType, j.schedule, j.tabName || 'default', j.message, j.enabled ? 1 : 0, 'local', j.createdAt, j.lastRunAt, j.nextRunAt);
+                }
+            });
+            tx();
+            fs.renameSync(jsonPath, jsonPath + '.bak');
+            logger.info(`Migrated ${jobs.length} cron jobs from JSON to SQLite`);
+        }
+        catch (err) {
+            logger.error('Failed to migrate cron jobs from JSON:', err);
+        }
+    }
+}
+//# sourceMappingURL=store.js.map

package/dist/machines/forwarder.d.ts

@@ -0,0 +1,7 @@
+import type { Machine } from './registry.js';
+/**
+ * Forward a message to a remote Beecork instance via SSH.
+ * Writes to the remote machine's pending_messages table.
+ */
+export declare function forwardToMachine(machine: Machine, tabName: string, message: string): Promise<boolean>;
+//# sourceMappingURL=forwarder.d.ts.map

package/dist/machines/forwarder.js

@@ -0,0 +1,35 @@
+import { execFileSync } from 'node:child_process';
+import { logger } from '../util/logger.js';
+import { validateTabName } from '../config.js';
+/**
+ * Forward a message to a remote Beecork instance via SSH.
+ * Writes to the remote machine's pending_messages table.
+ */
+export async function forwardToMachine(machine, tabName, message) {
+    if (!machine.host || !machine.sshUser) {
+        logger.warn(`Cannot forward to ${machine.name}: no SSH config`);
+        return false;
+    }
+    // Validate inputs to prevent injection via execFileSync args
+    if (tabName !== 'default') {
+        const tabError = validateTabName(tabName);
+        if (tabError) {
+            logger.error(`Invalid tab name for forwarding: ${tabError}`);
+            return false;
+        }
+    }
+    try {
+        // Use execFileSync with array args to prevent shell injection
+        execFileSync('ssh', [
+            `${machine.sshUser}@${machine.host}`,
+            'beecork', 'send', tabName, message,
+        ], { timeout: 30000, encoding: 'utf-8' });
+        logger.info(`Message forwarded to ${machine.name} (${machine.host}), tab: ${tabName}`);
+        return true;
+    }
+    catch (err) {
+        logger.error(`Failed to forward to ${machine.name}:`, err);
+        return false;
+    }
+}
+//# sourceMappingURL=forwarder.js.map

package/dist/machines/index.d.ts

@@ -0,0 +1 @@
+export { getMachineId, registerThisMachine, listMachines, type Machine } from './registry.js';

package/dist/machines/index.js

@@ -0,0 +1 @@
+export { getMachineId, registerThisMachine, listMachines } from './registry.js';

package/dist/machines/registry.d.ts

@@ -0,0 +1,15 @@
+export interface Machine {
+    id: string;
+    name: string;
+    host: string | null;
+    sshUser: string | null;
+    projectPaths: string[];
+    isPrimary: boolean;
+    lastSeenAt: string;
+}
+/** Get or create this machine's unique ID */
+export declare function getMachineId(): string;
+/** Register this machine in the database */
+export declare function registerThisMachine(projectPaths: string[]): Machine;
+/** List all machines */
+export declare function listMachines(): Machine[];

package/dist/machines/registry.js

@@ -0,0 +1,46 @@
+import os from 'node:os';
+import { v4 as uuidv4 } from 'uuid';
+import { getDb } from '../db/index.js';
+import { getBeecorkHome } from '../util/paths.js';
+import { logger } from '../util/logger.js';
+import fs from 'node:fs';
+const MACHINE_ID_PATH = `${getBeecorkHome()}/machine-id`;
+/** Get or create this machine's unique ID */
+export function getMachineId() {
+    if (fs.existsSync(MACHINE_ID_PATH)) {
+        return fs.readFileSync(MACHINE_ID_PATH, 'utf-8').trim();
+    }
+    const id = uuidv4();
+    fs.writeFileSync(MACHINE_ID_PATH, id, { mode: 0o600 });
+    return id;
+}
+/** Register this machine in the database */
+export function registerThisMachine(projectPaths) {
+    const db = getDb();
+    const id = getMachineId();
+    const name = os.hostname();
+    db.prepare(`
+    INSERT INTO machines (id, name, project_paths, last_seen_at)
+    VALUES (?, ?, ?, datetime('now'))
+    ON CONFLICT(id) DO UPDATE SET
+      name = excluded.name,
+      project_paths = excluded.project_paths,
+      last_seen_at = datetime('now')
+  `).run(id, name, JSON.stringify(projectPaths));
+    logger.info(`Machine registered: ${name} (${id.slice(0, 8)}) with ${projectPaths.length} project paths`);
+    return { id, name, host: null, sshUser: null, projectPaths, isPrimary: false, lastSeenAt: new Date().toISOString() };
+}
+/** List all machines */
+export function listMachines() {
+    const db = getDb();
+    const rows = db.prepare('SELECT * FROM machines ORDER BY is_primary DESC, name').all();
+    return rows.map(r => ({
+        id: r.id,
+        name: r.name,
+        host: r.host,
+        sshUser: r.ssh_user,
+        projectPaths: JSON.parse(r.project_paths || '[]'),
+        isPrimary: !!r.is_primary,
+        lastSeenAt: r.last_seen_at,
+    }));
+}

package/dist/media/loader.d.ts

@@ -0,0 +1,8 @@
+import type { MediaGenerator } from './types.js';
+/**
+ * Discover and load community media generator packages from node_modules.
+ * Convention: packages named `beecork-media-<name>` must export a default
+ * class implementing the MediaGenerator interface.
+ */
+export declare function loadCommunityGenerators(apiKeys?: Record<string, string>): Promise<MediaGenerator[]>;
+//# sourceMappingURL=loader.d.ts.map

package/dist/media/loader.js

@@ -0,0 +1,46 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { logger } from '../util/logger.js';
+const MEDIA_PREFIX = 'beecork-media-';
+/**
+ * Discover and load community media generator packages from node_modules.
+ * Convention: packages named `beecork-media-<name>` must export a default
+ * class implementing the MediaGenerator interface.
+ */
+export async function loadCommunityGenerators(apiKeys) {
+    const generators = [];
+    const searchPaths = [path.join(process.cwd(), 'node_modules')];
+    for (const searchPath of searchPaths) {
+        if (!fs.existsSync(searchPath))
+            continue;
+        try {
+            for (const dir of fs.readdirSync(searchPath)) {
+                if (!dir.startsWith(MEDIA_PREFIX))
+                    continue;
+                try {
+                    const pkgPath = path.join(searchPath, dir);
+                    const pkgJson = JSON.parse(fs.readFileSync(path.join(pkgPath, 'package.json'), 'utf-8'));
+                    const entryPath = path.join(pkgPath, pkgJson.main || 'index.js');
+                    if (!fs.existsSync(entryPath))
+                        continue;
+                    const module = await import(entryPath);
+                    const GeneratorClass = module.default || module[Object.keys(module)[0]];
+                    if (!GeneratorClass || typeof GeneratorClass !== 'function')
+                        continue;
+                    const name = dir.slice(MEDIA_PREFIX.length);
+                    const instance = new GeneratorClass(apiKeys?.[name]);
+                    if (!instance.id || !instance.name || typeof instance.generate !== 'function')
+                        continue;
+                    generators.push(instance);
+                    logger.info(`Community media generator loaded: ${instance.name} (${instance.id})`);
+                }
+                catch (err) {
+                    logger.warn(`Failed to load community generator ${dir}:`, err);
+                }
+            }
+        }
+        catch { }
+    }
+    return generators;
+}
+//# sourceMappingURL=loader.js.map

package/dist/memory/extractor.d.ts

@@ -0,0 +1,5 @@
+import type { BeecorkConfig } from '../types.js';
+/** Auto-extract memories from a completed session */
+export declare function extractMemories(config: BeecorkConfig, tabName: string, sessionText: string, durationMs: number): Promise<void>;
+/** Inject relevant memories into a prompt */
+export declare function getRelevantMemories(tabName: string): string[];

package/dist/memory/extractor.js

@@ -0,0 +1,157 @@
+import { spawn } from 'node:child_process';
+import { getDb } from '../db/index.js';
+import { logger } from '../util/logger.js';
+const EXTRACTION_PROMPT = `Extract 0-5 key facts, decisions, or outcomes from this session transcript that would be useful in future sessions. Output ONLY a JSON array of strings. If nothing is worth remembering, output an empty array [].
+
+Examples of what to extract:
+- Server addresses, credentials, file paths
+- User preferences ("prefers deployments after 11pm")
+- Decisions made ("chose PostgreSQL over MySQL for X reason")
+- Outcomes ("deploy succeeded", "bug was in auth middleware")
+
+Session transcript:
+`;
+/** Auto-extract memories from a completed session */
+export async function extractMemories(config, tabName, sessionText, durationMs) {
+    // Only extract from non-trivial sessions
+    if (durationMs < 10000 || sessionText.length < 200)
+        return;
+    // Rate limit: check if we extracted recently for this tab
+    const db = getDb();
+    const recent = db.prepare(`SELECT COUNT(*) as count FROM memories
+     WHERE tab_name = ? AND source = 'auto'
+     AND created_at > datetime('now', '-5 minutes')`).get(tabName);
+    if (recent.count > 0) {
+        logger.debug(`[${tabName}] Skipping memory extraction — too recent`);
+        return;
+    }
+    try {
+        const prompt = EXTRACTION_PROMPT + sessionText.slice(0, 5000); // Limit transcript size
+        const facts = await runExtractionSession(config, prompt);
+        if (facts.length === 0)
+            return;
+        for (const fact of facts) {
+            db.prepare('INSERT INTO memories (content, tab_name, source) VALUES (?, ?, ?)').run(fact, tabName, 'auto');
+        }
+        // Enforce maxLongTermEntries limit
+        const maxEntries = config.memory.maxLongTermEntries ?? 1000;
+        const count = db.prepare('SELECT COUNT(*) as c FROM memories').get().c;
+        if (count > maxEntries) {
+            const excess = count - maxEntries;
+            db.prepare('DELETE FROM memories WHERE rowid IN (SELECT rowid FROM memories ORDER BY created_at ASC LIMIT ?)').run(excess);
+            logger.info(`[${tabName}] Evicted ${excess} oldest memories (limit: ${maxEntries})`);
+        }
+        logger.info(`[${tabName}] Auto-extracted ${facts.length} memories`);
+    }
+    catch (err) {
+        logger.error(`[${tabName}] Memory extraction failed:`, err);
+    }
+}
+/** Inject relevant memories into a prompt */
+export function getRelevantMemories(tabName) {
+    const db = getDb();
+    // Get recent global memories + tab-specific memories
+    const memories = db.prepare(`SELECT content FROM memories
+     WHERE tab_name IS NULL OR tab_name = ?
+     ORDER BY created_at DESC LIMIT 20`).all(tabName);
+    return memories.map(m => m.content);
+}
+async function runExtractionSession(config, prompt) {
+    // Prefer direct API call (cheaper, faster) when API key is available
+    if (config.pipe?.anthropicApiKey) {
+        return runExtractionViaApi(config.pipe.anthropicApiKey, config.pipe.routingModel, prompt);
+    }
+    // Fallback: spawn Claude Code subprocess
+    return runExtractionViaSubprocess(config, prompt);
+}
+function parseFactsFromText(text) {
+    const jsonMatch = text.match(/\[[\s\S]*?\]/);
+    if (jsonMatch) {
+        const facts = JSON.parse(jsonMatch[0]);
+        if (Array.isArray(facts) && facts.every(f => typeof f === 'string')) {
+            return facts.slice(0, 5);
+        }
+    }
+    return [];
+}
+let cachedClient = null;
+let cachedApiKey = '';
+async function runExtractionViaApi(apiKey, model, prompt) {
+    const { default: Anthropic } = await import('@anthropic-ai/sdk');
+    if (!cachedClient || cachedApiKey !== apiKey) {
+        cachedClient = new Anthropic({ apiKey });
+        cachedApiKey = apiKey;
+    }
+    const client = cachedClient;
+    try {
+        const response = await client.messages.create({
+            model,
+            max_tokens: 500,
+            system: 'Extract 0-5 key facts from this session transcript worth remembering across sessions. Output ONLY a JSON array of strings. If nothing is worth remembering, output [].',
+            messages: [{ role: 'user', content: prompt }],
+        }, { timeout: 15000 });
+        const text = response.content.find((b) => b.type === 'text')?.text ?? '[]';
+        return parseFactsFromText(text);
+    }
+    catch (err) {
+        logger.warn('API-based memory extraction failed, falling back to subprocess:', err);
+        return [];
+    }
+}
+async function runExtractionViaSubprocess(config, prompt) {
+    return new Promise((resolve, reject) => {
+        let resolved = false;
+        const safeResolve = (val) => { if (!resolved) {
+            resolved = true;
+            resolve(val);
+        } };
+        const safeReject = (err) => { if (!resolved) {
+            resolved = true;
+            reject(err);
+        } };
+        const args = [
+            '-p',
+            '--output-format', 'stream-json',
+            '--verbose',
+            ...config.claudeCode.defaultFlags,
+            '--no-session-persistence',
+            prompt,
+        ];
+        const proc = spawn(config.claudeCode.bin, args, {
+            cwd: process.cwd(),
+            stdio: ['ignore', 'pipe', 'pipe'],
+        });
+        let output = '';
+        let stdoutBuffer = '';
+        proc.stdout.on('data', (chunk) => {
+            stdoutBuffer += chunk.toString();
+            const lines = stdoutBuffer.split('\n');
+            stdoutBuffer = lines.pop() || '';
+            for (const line of lines) {
+                if (!line.trim())
+                    continue;
+                try {
+                    const event = JSON.parse(line);
+                    if (event.type === 'result' && event.result) {
+                        output = event.result;
+                    }
+                }
+                catch { /* skip non-JSON */ }
+            }
+        });
+        proc.on('exit', () => {
+            clearTimeout(timer);
+            try {
+                safeResolve(parseFactsFromText(output));
+            }
+            catch {
+                safeResolve([]);
+            }
+        });
+        proc.on('error', safeReject);
+        const timer = setTimeout(() => {
+            proc.kill('SIGTERM');
+            safeResolve([]);
+        }, 30000);
+    });
+}