beecork 1.7.1 → 2.0.0

package/dist/media/types.d.ts

@@ -1,43 +0,0 @@
-export type MediaType = 'image' | 'video' | 'audio' | 'music';
-export interface GenerateOptions {
-    style?: string;
-    model?: string;
-    width?: number;
-    height?: number;
-    duration?: number;
-    format?: string;
-}
-export interface GenerateResult {
-    filePath: string;
-    mimeType: string;
-    durationMs?: number;
-    metadata?: Record<string, unknown>;
-}
-export interface MediaGenerator {
-    readonly id: string;
-    readonly name: string;
-    readonly supportedTypes: MediaType[];
-    generate(type: MediaType, prompt: string, options?: GenerateOptions): Promise<GenerateResult>;
-}
-/** Gemini `:generateContent` response shape (used by lyria + nano-banana). */
-export interface GeminiInlineDataPart {
-    inlineData?: {
-        mimeType?: string;
-        data: string;
-    };
-}
-export interface GeminiCandidate {
-    content?: {
-        parts?: GeminiInlineDataPart[];
-    };
-}
-export interface GeminiGenerateContentResponse {
-    candidates?: GeminiCandidate[];
-}
-/** Recraft `/v1/images/generations` response. */
-export interface RecraftGenerateResponse {
-    data?: Array<{
-        url?: string;
-        b64_json?: string;
-    }>;
-}

package/dist/media/types.js

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

package/dist/memory/extractor.d.ts

@@ -1,5 +0,0 @@
-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

@@ -1,157 +0,0 @@
-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);
-    });
-}

package/dist/notifications/index.d.ts

@@ -1,4 +0,0 @@
-export type { NotificationProvider } from './types.js';
-import type { NotificationProvider } from './types.js';
-import type { NotificationConfig } from '../types.js';
-export declare function createNotificationProvider(config: NotificationConfig): NotificationProvider | null;

package/dist/notifications/index.js

@@ -1,21 +0,0 @@
-import { logger } from '../util/logger.js';
-import { PushoverProvider } from './pushover.js';
-import { NtfyProvider } from './ntfy.js';
-import { WebhookNotificationProvider } from './webhook-provider.js';
-export function createNotificationProvider(config) {
-    switch (config.type) {
-        case 'pushover':
-            return new PushoverProvider(config.userKey, config.appToken);
-        case 'ntfy':
-            return new NtfyProvider(config.topic, config.server);
-        case 'webhook':
-            return new WebhookNotificationProvider(config.url, config.headers);
-        default: {
-            // Exhaustiveness check — TS will error here if NotificationConfig gains
-            // a new variant without a matching case above.
-            const _exhaustive = config;
-            logger.warn(`Unknown notification provider: ${JSON.stringify(_exhaustive)}`);
-            return null;
-        }
-    }
-}

package/dist/notifications/ntfy.d.ts

@@ -1,9 +0,0 @@
-import type { NotificationProvider } from './types.js';
-export declare class NtfyProvider implements NotificationProvider {
-    private topic;
-    private server;
-    readonly id = "ntfy";
-    readonly name = "ntfy.sh";
-    constructor(topic: string, server?: string);
-    send(message: string, urgent?: boolean): Promise<void>;
-}

package/dist/notifications/ntfy.js

@@ -1,25 +0,0 @@
-export class NtfyProvider {
-    topic;
-    server;
-    id = 'ntfy';
-    name = 'ntfy.sh';
-    constructor(topic, server = 'https://ntfy.sh') {
-        this.topic = topic;
-        this.server = server;
-    }
-    async send(message, urgent) {
-        const response = await fetch(`${this.server}/${this.topic}`, {
-            method: 'POST',
-            headers: {
-                Title: 'Beecork',
-                Priority: urgent ? '5' : '3',
-                Tags: urgent ? 'warning' : 'robot',
-            },
-            body: message,
-            signal: AbortSignal.timeout(10000),
-        });
-        if (!response.ok) {
-            throw new Error(`ntfy error: ${response.status}`);
-        }
-    }
-}

package/dist/notifications/pushover.d.ts

@@ -1,9 +0,0 @@
-import type { NotificationProvider } from './types.js';
-export declare class PushoverProvider implements NotificationProvider {
-    private userKey;
-    private appToken;
-    readonly id = "pushover";
-    readonly name = "Pushover";
-    constructor(userKey: string, appToken: string);
-    send(message: string, urgent?: boolean): Promise<void>;
-}

package/dist/notifications/pushover.js

@@ -1,26 +0,0 @@
-export class PushoverProvider {
-    userKey;
-    appToken;
-    id = 'pushover';
-    name = 'Pushover';
-    constructor(userKey, appToken) {
-        this.userKey = userKey;
-        this.appToken = appToken;
-    }
-    async send(message, urgent) {
-        const response = await fetch('https://api.pushover.net/1/messages.json', {
-            method: 'POST',
-            headers: { 'Content-Type': 'application/json' },
-            body: JSON.stringify({
-                token: this.appToken,
-                user: this.userKey,
-                message: message.slice(0, 1024),
-                priority: urgent ? 1 : 0,
-            }),
-            signal: AbortSignal.timeout(10000),
-        });
-        if (!response.ok) {
-            throw new Error(`Pushover API error: ${response.status}`);
-        }
-    }
-}

package/dist/notifications/types.d.ts

@@ -1,5 +0,0 @@
-export interface NotificationProvider {
-    readonly id: string;
-    readonly name: string;
-    send(message: string, urgent?: boolean): Promise<void>;
-}

package/dist/notifications/types.js

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

package/dist/notifications/webhook-provider.d.ts

@@ -1,9 +0,0 @@
-import type { NotificationProvider } from './types.js';
-export declare class WebhookNotificationProvider implements NotificationProvider {
-    private url;
-    private headers?;
-    readonly id = "webhook-notify";
-    readonly name = "Webhook";
-    constructor(url: string, headers?: Record<string, string> | undefined);
-    send(message: string, urgent?: boolean): Promise<void>;
-}

package/dist/notifications/webhook-provider.js

@@ -1,24 +0,0 @@
-export class WebhookNotificationProvider {
-    url;
-    headers;
-    id = 'webhook-notify';
-    name = 'Webhook';
-    constructor(url, headers) {
-        this.url = url;
-        this.headers = headers;
-    }
-    async send(message, urgent) {
-        const response = await fetch(this.url, {
-            method: 'POST',
-            headers: {
-                'Content-Type': 'application/json',
-                ...this.headers,
-            },
-            body: JSON.stringify({ message, urgent: !!urgent, timestamp: new Date().toISOString() }),
-            signal: AbortSignal.timeout(10000),
-        });
-        if (!response.ok) {
-            throw new Error(`Webhook notification error: ${response.status}`);
-        }
-    }
-}

package/dist/observability/analytics.d.ts

@@ -1,30 +0,0 @@
-import type Database from 'better-sqlite3';
-export interface CostSummary {
-    today: number;
-    last7Days: number;
-    last30Days: number;
-    perTab: Array<{
-        name: string;
-        cost: number;
-        messages: number;
-    }>;
-}
-export interface ActivitySummary {
-    period: string;
-    messagesReceived: number;
-    messagesFromAssistant: number;
-    tasksFired: number;
-    memoriesCreated: number;
-    totalCost: number;
-    activeTabsCount: number;
-}
-export declare function getCostSummary(): CostSummary;
-export declare function getActivitySummary(hours?: number): ActivitySummary;
-/**
- * Returns a notification only on state transitions (ok↔breach), persisting
- * the state in the `preferences` table so daemon restarts don't re-fire.
- */
-export declare function checkAnomaliesWithDb(db: Database.Database): string | null;
-export declare function checkAnomalies(): string | null;
-export declare function formatCostSummary(summary: CostSummary): string;
-export declare function formatActivitySummary(summary: ActivitySummary): string;

package/dist/observability/analytics.js

@@ -1,118 +0,0 @@
-import { getDb } from '../db/index.js';
-export function getCostSummary() {
-    const db = getDb();
-    const today = db
-        .prepare("SELECT COALESCE(SUM(cost_usd), 0) as total FROM messages WHERE created_at > date('now')")
-        .get().total;
-    const last7 = db
-        .prepare("SELECT COALESCE(SUM(cost_usd), 0) as total FROM messages WHERE created_at > date('now', '-7 days')")
-        .get().total;
-    const last30 = db
-        .prepare("SELECT COALESCE(SUM(cost_usd), 0) as total FROM messages WHERE created_at > date('now', '-30 days')")
-        .get().total;
-    // Per-tab summed over the last 30 days only — the unbounded version grew
-    // linearly with the messages table and made /cost noticeably slow over time.
-    const perTab = db
-        .prepare(`
-    SELECT t.name, COALESCE(SUM(m.cost_usd), 0) as cost, COUNT(m.id) as messages
-    FROM tabs t LEFT JOIN messages m ON m.tab_id = t.id
-      AND m.created_at > date('now', '-30 days')
-    GROUP BY t.id ORDER BY cost DESC
-  `)
-        .all();
-    return { today, last7Days: last7, last30Days: last30, perTab };
-}
-export function getActivitySummary(hours = 24) {
-    const db = getDb();
-    const sinceDate = new Date(Date.now() - hours * 3600000).toISOString();
-    const messagesReceived = db
-        .prepare('SELECT COUNT(*) as c FROM messages WHERE role = ? AND created_at > ?')
-        .get('user', sinceDate).c;
-    const messagesFromAssistant = db
-        .prepare('SELECT COUNT(*) as c FROM messages WHERE role = ? AND created_at > ?')
-        .get('assistant', sinceDate).c;
-    const tasksFired = db.prepare('SELECT COUNT(*) as c FROM tasks WHERE last_run_at > ?').get(sinceDate).c;
-    const memoriesCreated = db.prepare('SELECT COUNT(*) as c FROM memories WHERE created_at > ?').get(sinceDate).c;
-    const totalCost = db
-        .prepare('SELECT COALESCE(SUM(cost_usd), 0) as total FROM messages WHERE created_at > ?')
-        .get(sinceDate).total;
-    const activeTabsCount = db
-        .prepare('SELECT COUNT(DISTINCT tab_id) as c FROM messages WHERE created_at > ?')
-        .get(sinceDate).c;
-    return {
-        period: `Last ${hours} hours`,
-        messagesReceived,
-        messagesFromAssistant,
-        tasksFired,
-        memoriesCreated,
-        totalCost,
-        activeTabsCount,
-    };
-}
-const ANOMALY_STATE_KEY = 'anomaly_spend_state';
-/**
- * Returns a notification only on state transitions (ok↔breach), persisting
- * the state in the `preferences` table so daemon restarts don't re-fire.
- */
-export function checkAnomaliesWithDb(db) {
-    // Today's spend
-    const todaySpend = db
-        .prepare("SELECT COALESCE(SUM(cost_usd), 0) as total FROM messages WHERE created_at > date('now')")
-        .get().total;
-    // 7-day rolling average (excluding today)
-    const avgSpend = db
-        .prepare(`
-    SELECT COALESCE(AVG(daily_total), 0) as avg FROM (
-      SELECT date(created_at) as day, SUM(cost_usd) as daily_total
-      FROM messages
-      WHERE created_at > date('now', '-7 days') AND created_at < date('now')
-      GROUP BY date(created_at)
-    )
-  `)
-        .get().avg;
-    const isBreach = avgSpend > 0 && todaySpend > avgSpend * 2;
-    const newState = isBreach ? 'breach' : 'ok';
-    const prevRow = db
-        .prepare('SELECT value FROM preferences WHERE key = ?')
-        .get(ANOMALY_STATE_KEY);
-    const prevState = prevRow?.value ?? 'ok';
-    if (newState === prevState)
-        return null;
-    db.prepare(`INSERT INTO preferences (key, value, updated_at) VALUES (?, ?, datetime('now'))
-     ON CONFLICT(key) DO UPDATE SET value = excluded.value, updated_at = datetime('now')`).run(ANOMALY_STATE_KEY, newState);
-    if (isBreach) {
-        return `⚠️ Anomaly: Today's spend ($${todaySpend.toFixed(4)}) exceeds 2x your 7-day average ($${avgSpend.toFixed(4)}/day)`;
-    }
-    return `✅ Recovered: Today's spend ($${todaySpend.toFixed(4)}) is back within 2x your 7-day average ($${avgSpend.toFixed(4)}/day)`;
-}
-export function checkAnomalies() {
-    return checkAnomaliesWithDb(getDb());
-}
-export function formatCostSummary(summary) {
-    const lines = [
-        `💰 Cost Summary`,
-        `  Today: $${summary.today.toFixed(4)}`,
-        `  7 days: $${summary.last7Days.toFixed(4)}`,
-        `  30 days: $${summary.last30Days.toFixed(4)}`,
-    ];
-    if (summary.perTab.length > 0) {
-        lines.push('', '  Per tab:');
-        for (const tab of summary.perTab.slice(0, 10)) {
-            if (tab.cost > 0) {
-                lines.push(`    ${tab.name}: $${tab.cost.toFixed(4)} (${tab.messages} msgs)`);
-            }
-        }
-    }
-    return lines.join('\n');
-}
-export function formatActivitySummary(summary) {
-    return [
-        `📊 Activity (${summary.period})`,
-        `  Messages in: ${summary.messagesReceived}`,
-        `  Messages out: ${summary.messagesFromAssistant}`,
-        `  Tasks fired: ${summary.tasksFired}`,
-        `  Memories created: ${summary.memoriesCreated}`,
-        `  Active tabs: ${summary.activeTabsCount}`,
-        `  Cost: $${summary.totalCost.toFixed(4)}`,
-    ].join('\n');
-}

package/dist/pipe/anthropic-client.d.ts

@@ -1,9 +0,0 @@
-import type { RouteDecision, Project } from './types.js';
-export declare class PipeAnthropicClient {
-    private client;
-    private routingModel;
-    constructor(apiKey: string, routingModel: string);
-    /** Route a message to the right project/tab (Haiku — fast, cheap) */
-    route(message: string, projects: Project[], recentRouting: string[]): Promise<RouteDecision>;
-    private complete;
-}

package/dist/pipe/anthropic-client.js

@@ -1,50 +0,0 @@
-import Anthropic from '@anthropic-ai/sdk';
-import { logger } from '../util/logger.js';
-import { retryWithBackoff } from '../util/retry.js';
-export class PipeAnthropicClient {
-    client;
-    routingModel;
-    constructor(apiKey, routingModel) {
-        this.client = new Anthropic({ apiKey });
-        this.routingModel = routingModel;
-    }
-    /** Route a message to the right project/tab (Haiku — fast, cheap) */
-    async route(message, projects, recentRouting) {
-        const projectList = projects.map(p => `- ${p.name}: ${p.path}${p.languages?.length ? ` (${p.languages.join(', ')})` : ''}${p.description ? ` — ${p.description}` : ''}`).join('\n');
-        const response = await this.complete(`You are a message router. Given a user message, determine which project it relates to.
-
-Available projects:
-${projectList || '(no projects discovered yet)'}
-
-Recent routing decisions:
-${recentRouting.slice(0, 5).join('\n') || '(none)'}
-
-Respond with ONLY valid JSON: {"tabName": "project-name", "projectPath": "/path", "confidence": 0.0-1.0, "reason": "brief explanation", "needsConfirmation": false}
-
-If the message is a general question not related to any project, use tabName "default" with the user's home directory.
-If unsure which project, set confidence below 0.5 and needsConfirmation to true.`, message);
-        try {
-            return JSON.parse(response);
-        }
-        catch {
-            logger.warn('Failed to parse routing response:', response);
-            return { tabName: 'default', projectPath: null, confidence: 0.3, reason: 'Could not parse routing', needsConfirmation: true };
-        }
-    }
-    async complete(systemPrompt, userMessage) {
-        try {
-            const response = await retryWithBackoff(() => this.client.messages.create({
-                model: this.routingModel,
-                max_tokens: 500,
-                system: systemPrompt,
-                messages: [{ role: 'user', content: userMessage }],
-            }, { timeout: 30000 }), [1000, 5000, 15000], `Pipe API call (routing)`);
-            const textBlock = response.content.find(b => b.type === 'text');
-            return textBlock?.text ?? '';
-        }
-        catch (err) {
-            logger.error(`Pipe API call failed (routing):`, err);
-            throw err;
-        }
-    }
-}

package/dist/pipe/brain.d.ts

@@ -1,16 +0,0 @@
-import type { TabManager } from '../session/manager.js';
-import type { BeecorkConfig } from '../types.js';
-import type { ChatContext, PipeResult } from './types.js';
-export declare class PipeBrain {
-    private client;
-    private memory;
-    private config;
-    private tabManager;
-    constructor(config: BeecorkConfig, tabManager: TabManager);
-    /** Main entry point: route a message to the right tab and send it to Claude. */
-    process(message: string, _context: ChatContext): Promise<PipeResult>;
-    /** Route a message to the right project/tab */
-    private route;
-    /** Discover projects on the filesystem */
-    discoverProjects(): Promise<number>;
-}