beecork 1.7.0 → 2.0.0

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/projects/index.d.ts

@@ -1,4 +0,0 @@
-export type { Project, RouteDecision, RoutingContext } from './types.js';
-export { discoverProjects, createProject, listProjects, getProject, ensureCategory, touchProject, } from './manager.js';
-export { routeMessage, setUserContext, resolveProjectRoute } from './router.js';
-export type { RouteResult } from './router.js';

package/dist/projects/index.js

@@ -1,2 +0,0 @@
-export { discoverProjects, createProject, listProjects, getProject, ensureCategory, touchProject, } from './manager.js';
-export { routeMessage, setUserContext, resolveProjectRoute } from './router.js';

package/dist/projects/manager.d.ts

@@ -1,13 +0,0 @@
-import type { Project } from './types.js';
-/** Discover projects in scan paths (look for git repos, package.json, etc.) */
-export declare function discoverProjects(scanPaths?: string[]): Project[];
-/** Create a new project. parentDir must resolve under an allowed root. */
-export declare function createProject(name: string, parentDir?: string): Project;
-/** Ensure a managed category exists (lazy creation) */
-export declare function ensureCategory(name: string): Project;
-/** List all projects */
-export declare function listProjects(): Project[];
-/** Get a project by name */
-export declare function getProject(name: string): Project | null;
-/** Update last used timestamp */
-export declare function touchProject(name: string): void;

package/dist/projects/manager.js

@@ -1,166 +0,0 @@
-import fs from 'node:fs';
-import path from 'node:path';
-import { v4 as uuidv4 } from 'uuid';
-import { getDb } from '../db/index.js';
-import { getConfig } from '../config.js';
-import { expandHome } from '../util/paths.js';
-import { logger } from '../util/logger.js';
-import { invalidateProjectCache } from './router.js';
-function rowToProject(r) {
-    return {
-        id: r.id,
-        name: r.name,
-        path: r.path,
-        type: r.type,
-        lastUsedAt: r.last_used_at,
-        createdAt: r.created_at,
-    };
-}
-/** Get the workspace root from config (module-local) */
-function getWorkspaceRoot() {
-    const config = getConfig();
-    // Use the default tab's workingDir as workspace root
-    const root = config.tabs?.default?.workingDir || process.env.HOME || '';
-    return expandHome(root);
-}
-/** Get the managed workspace path (.beecork/ under workspace root) (module-local) */
-function getManagedWorkspace() {
-    return path.join(getWorkspaceRoot(), '.beecork');
-}
-/** Discover projects in scan paths (look for git repos, package.json, etc.) */
-export function discoverProjects(scanPaths) {
-    const paths = scanPaths || [getWorkspaceRoot()];
-    const projects = [];
-    const db = getDb();
-    for (let scanPath of paths) {
-        scanPath = expandHome(scanPath);
-        if (!fs.existsSync(scanPath))
-            continue;
-        try {
-            const entries = fs.readdirSync(scanPath, { withFileTypes: true });
-            for (const entry of entries) {
-                if (!entry.isDirectory())
-                    continue;
-                if (entry.name.startsWith('.'))
-                    continue; // Skip hidden dirs
-                if (entry.name === 'node_modules')
-                    continue;
-                const dirPath = path.join(scanPath, entry.name);
-                // Check if it looks like a project (has .git, package.json, or similar)
-                const isProject = fs.existsSync(path.join(dirPath, '.git')) ||
-                    fs.existsSync(path.join(dirPath, 'package.json')) ||
-                    fs.existsSync(path.join(dirPath, 'Cargo.toml')) ||
-                    fs.existsSync(path.join(dirPath, 'go.mod')) ||
-                    fs.existsSync(path.join(dirPath, 'requirements.txt')) ||
-                    fs.existsSync(path.join(dirPath, 'pyproject.toml')) ||
-                    fs.existsSync(path.join(dirPath, 'CLAUDE.md'));
-                if (isProject) {
-                    projects.push({
-                        id: uuidv4(),
-                        name: entry.name,
-                        path: dirPath,
-                        type: 'user-project',
-                        lastUsedAt: new Date().toISOString(),
-                        createdAt: new Date().toISOString(),
-                    });
-                }
-            }
-        }
-        catch (err) {
-            logger.warn(`Failed to scan ${scanPath}:`, err);
-        }
-    }
-    // Upsert into database
-    for (const project of projects) {
-        db.prepare(`
-      INSERT INTO projects (id, name, path, type) VALUES (?, ?, ?, ?)
-      ON CONFLICT(name) DO UPDATE SET path = excluded.path, last_used_at = datetime('now')
-    `).run(project.id, project.name, project.path, project.type);
-    }
-    invalidateProjectCache();
-    return projects;
-}
-/** Create a new project. parentDir must resolve under an allowed root. */
-export function createProject(name, parentDir) {
-    const requestedParent = parentDir || getWorkspaceRoot();
-    const resolvedParent = path.resolve(expandHome(requestedParent));
-    // Allowlist: parent must resolve under workspace root or one of the configured scan paths.
-    const config = getConfig();
-    const allowedRoots = [getWorkspaceRoot(), ...(config.projectScanPaths ?? [])].map((r) => path.resolve(expandHome(r)));
-    const isAllowed = allowedRoots.some((root) => resolvedParent === root || resolvedParent.startsWith(root + path.sep));
-    if (!isAllowed) {
-        throw new Error(`Project parent directory must be under workspace root or a configured scan path. Allowed: ${allowedRoots.join(', ')}`);
-    }
-    // Sanitize name to prevent path traversal
-    const safeName = path.basename(name.replace(/\.\./g, ''));
-    if (!safeName)
-        throw new Error('Invalid project name');
-    const projectPath = path.resolve(resolvedParent, safeName);
-    // Ensure resolved path is within the parent directory
-    if (!projectPath.startsWith(resolvedParent)) {
-        throw new Error('Project path must be within the parent directory');
-    }
-    if (fs.existsSync(projectPath)) {
-        // Folder already exists — just register it
-        logger.info(`Project folder already exists: ${projectPath}`);
-    }
-    else {
-        fs.mkdirSync(projectPath, { recursive: true });
-        logger.info(`Created project folder: ${projectPath}`);
-    }
-    const db = getDb();
-    const id = uuidv4();
-    db.prepare(`
-    INSERT INTO projects (id, name, path, type) VALUES (?, ?, ?, ?)
-    ON CONFLICT(name) DO UPDATE SET path = excluded.path
-  `).run(id, name, projectPath, 'user-project');
-    invalidateProjectCache();
-    return {
-        id,
-        name,
-        path: projectPath,
-        type: 'user-project',
-        lastUsedAt: new Date().toISOString(),
-        createdAt: new Date().toISOString(),
-    };
-}
-/** Ensure a managed category exists (lazy creation) */
-export function ensureCategory(name) {
-    const categoryPath = path.join(getManagedWorkspace(), name);
-    fs.mkdirSync(categoryPath, { recursive: true });
-    const db = getDb();
-    const existing = db
-        .prepare('SELECT * FROM projects WHERE name = ? AND type = ?')
-        .get(name, 'category');
-    if (existing)
-        return rowToProject(existing);
-    const id = uuidv4();
-    db.prepare('INSERT INTO projects (id, name, path, type) VALUES (?, ?, ?, ?)').run(id, name, categoryPath, 'category');
-    invalidateProjectCache();
-    return {
-        id,
-        name,
-        path: categoryPath,
-        type: 'category',
-        lastUsedAt: new Date().toISOString(),
-        createdAt: new Date().toISOString(),
-    };
-}
-/** List all projects */
-export function listProjects() {
-    const db = getDb();
-    const rows = db
-        .prepare('SELECT * FROM projects ORDER BY type, last_used_at DESC')
-        .all();
-    return rows.map(rowToProject);
-}
-/** Get a project by name */
-export function getProject(name) {
-    const db = getDb();
-    const row = db.prepare('SELECT * FROM projects WHERE name = ?').get(name);
-    return row ? rowToProject(row) : null;
-}
-/** Update last used timestamp */
-export function touchProject(name) {
-    getDb().prepare("UPDATE projects SET last_used_at = datetime('now') WHERE name = ?").run(name);
-}

package/dist/projects/router.d.ts

@@ -1,17 +0,0 @@
-import type { RouteDecision, RoutingContext } from './types.js';
-/** Invalidate the project cache. Call after createProject/discoverProjects/etc. */
-export declare function invalidateProjectCache(): void;
-/** Route a message to the right project and tab */
-export declare function routeMessage(message: string, context?: RoutingContext): RouteDecision;
-/** Update current context for a user */
-export declare function setUserContext(userId: string, projectName: string, tabName: string): void;
-export interface RouteResult {
-    effectiveTabName: string;
-    projectPath?: string;
-    confirmationMessage?: string;
-}
-/**
- * Shared project routing logic — resolves which tab/project to use for a message.
- * Pulled out of channels/ so all routing decisions live in one place.
- */
-export declare function resolveProjectRoute(rawPrompt: string, tabName: string, text: string, userId: string): Promise<RouteResult>;