beecork 1.7.0 → 2.0.0

package/dist/projects/router.js

@@ -1,246 +0,0 @@
-import { getDb } from '../db/index.js';
-import { listProjects, getProject, ensureCategory, touchProject } from './manager.js';
-// Category keywords for non-project routing
-const CATEGORY_KEYWORDS = {
-    research: ['research', 'find out', 'look into', 'compare', 'investigate', 'analyze', 'study'],
-    planning: ['plan', 'schedule', 'organize', 'roadmap', 'strategy', 'outline', 'agenda'],
-};
-// Per-user current context tracking (in-memory, resets on daemon restart)
-const userContext = new Map();
-// Project list cache. listProjects() ran on every inbound message and re-did a
-// full SELECT + ORDER BY across the projects table; with N projects each call
-// then re-lowercased every name. The cache is invalidated explicitly via
-// invalidateProjectCache() at the few sites that mutate the table.
-let projectsCache = null;
-const PROJECTS_CACHE_TTL_MS = 30_000;
-function getUserProjectsCached() {
-    const now = Date.now();
-    if (projectsCache && projectsCache.expiresAt > now)
-        return projectsCache.user;
-    const user = listProjects()
-        .filter((p) => p.type === 'user-project')
-        .map((p) => ({ ...p, nameLower: p.name.toLowerCase() }));
-    projectsCache = { user, expiresAt: now + PROJECTS_CACHE_TTL_MS };
-    return user;
-}
-/** Invalidate the project cache. Call after createProject/discoverProjects/etc. */
-export function invalidateProjectCache() {
-    projectsCache = null;
-}
-/** Route a message to the right project and tab */
-export function routeMessage(message, context) {
-    const projects = getUserProjectsCached();
-    const userId = context?.userId || 'default';
-    const messageLower = message.toLowerCase();
-    // 1. Check for explicit project mention by name
-    const mentionedProject = findMentionedProject(messageLower, projects);
-    if (mentionedProject) {
-        const { tabName, exists } = resolveTabInProject(mentionedProject);
-        touchProject(mentionedProject.name);
-        recordRouting(message, mentionedProject.name);
-        return {
-            project: mentionedProject,
-            tabName,
-            isNewTab: !exists,
-            confidence: 0.95,
-            needsConfirmation: false,
-            reason: `Message mentions project "${mentionedProject.name}"`,
-        };
-    }
-    // 2. Check if continuing current context
-    const currentCtx = userContext.get(userId);
-    if (currentCtx && Date.now() - currentCtx.updatedAt < 10 * 60 * 1000) {
-        // 10 min window
-        const project = getProject(currentCtx.projectName);
-        if (project) {
-            touchProject(project.name);
-            return {
-                project,
-                tabName: currentCtx.tabName,
-                isNewTab: false,
-                confidence: 0.7,
-                needsConfirmation: false,
-                reason: `Continuing in "${project.name}" (recent context)`,
-            };
-        }
-    }
-    // 3. Check routing preferences (learned patterns)
-    const learned = checkLearnedRouting(messageLower);
-    if (learned) {
-        const project = getProject(learned.projectName);
-        if (project && learned.confidence >= 0.9) {
-            const { tabName, exists } = resolveTabInProject(project);
-            touchProject(project.name);
-            return {
-                project,
-                tabName,
-                isNewTab: !exists,
-                confidence: learned.confidence,
-                needsConfirmation: false,
-                reason: `Learned pattern → "${project.name}"`,
-            };
-        }
-    }
-    // 4. Multiple projects could match — ask user
-    const possibleMatches = findPossibleMatches(messageLower, projects);
-    if (possibleMatches.length > 1) {
-        return {
-            project: possibleMatches[0],
-            tabName: possibleMatches[0].name,
-            isNewTab: false,
-            confidence: 0.5,
-            needsConfirmation: true,
-            reason: `Multiple projects could match: ${possibleMatches.map((p) => p.name).join(', ')}`,
-        };
-    }
-    // 5. Check for category keywords (non-project)
-    const category = detectCategory(messageLower);
-    if (category) {
-        const project = ensureCategory(category);
-        const tabName = category;
-        return {
-            project,
-            tabName,
-            isNewTab: !tabExists(tabName),
-            confidence: 0.8,
-            needsConfirmation: false,
-            reason: `Detected category: ${category}`,
-        };
-    }
-    // 6. Default to general
-    const general = ensureCategory('general');
-    return {
-        project: general,
-        tabName: 'general',
-        isNewTab: !tabExists('general'),
-        confidence: 0.6,
-        needsConfirmation: false,
-        reason: 'Default routing to general',
-    };
-}
-/** Update current context for a user */
-export function setUserContext(userId, projectName, tabName) {
-    userContext.set(userId, { projectName, tabName, updatedAt: Date.now() });
-    // Evict oldest entry when map grows too large
-    if (userContext.size > 1000) {
-        let oldestKey = '';
-        let oldestTime = Infinity;
-        for (const [key, val] of userContext) {
-            if (val.updatedAt < oldestTime) {
-                oldestTime = val.updatedAt;
-                oldestKey = key;
-            }
-        }
-        if (oldestKey)
-            userContext.delete(oldestKey);
-    }
-}
-/** Find a project explicitly mentioned by name in the message (messageLower already lower-cased) */
-function findMentionedProject(messageLower, projects) {
-    for (const project of projects) {
-        if (messageLower.includes(project.nameLower))
-            return project;
-    }
-    return null;
-}
-/** Find possible project matches (for ambiguity) */
-function findPossibleMatches(messageLower, projects) {
-    const words = messageLower.split(/\s+/);
-    return projects.filter((p) => {
-        const nameParts = p.nameLower.split(/[-_]/);
-        return nameParts.some((part) => words.includes(part));
-    });
-}
-/**
- * Resolve which tab to use within a project. Coalesces the previous
- * "find tabs + tabExists" into one query — the caller used to fire both
- * back-to-back, and the working_dir scan had no covering index.
- * (Index added by migration v28; see src/db/migrations.ts.)
- */
-function resolveTabInProject(project) {
-    const db = getDb();
-    const row = db
-        .prepare('SELECT name FROM tabs WHERE working_dir = ? ORDER BY last_activity_at DESC LIMIT 1')
-        .get(project.path);
-    return row ? { tabName: row.name, exists: true } : { tabName: project.name, exists: false };
-}
-/** Check if a tab exists in the database */
-function tabExists(tabName) {
-    const db = getDb();
-    const row = db.prepare('SELECT 1 FROM tabs WHERE name = ?').get(tabName);
-    return !!row;
-}
-/** Detect a category from keywords (messageLower already lower-cased) */
-function detectCategory(messageLower) {
-    for (const [category, keywords] of Object.entries(CATEGORY_KEYWORDS)) {
-        if (keywords.some((kw) => messageLower.includes(kw)))
-            return category;
-    }
-    return null;
-}
-/** Record a successful routing for learning */
-function recordRouting(message, projectName) {
-    const db = getDb();
-    // Extract key words from message for pattern matching
-    const words = message
-        .toLowerCase()
-        .split(/\s+/)
-        .filter((w) => w.length > 3)
-        .slice(0, 5);
-    const pattern = words.join(' ');
-    if (!pattern)
-        return;
-    db.prepare(`
-    INSERT INTO routing_preferences (pattern, project_name)
-    VALUES (?, ?)
-    ON CONFLICT(pattern, project_name) DO UPDATE SET hit_count = hit_count + 1
-  `).run(pattern, projectName);
-}
-/** Check learned routing preferences (messageLower already lower-cased) */
-function checkLearnedRouting(messageLower) {
-    const db = getDb();
-    const words = messageLower.split(/\s+/).filter((w) => w.length > 3);
-    if (words.length === 0)
-        return null;
-    // Fetch all preferences in a single query and match in JS
-    const allPrefs = db
-        .prepare('SELECT pattern, project_name, confidence, hit_count FROM routing_preferences WHERE hit_count >= 3 ORDER BY hit_count DESC LIMIT 200')
-        .all();
-    for (const pref of allPrefs) {
-        // pref.pattern was written via .toLowerCase() in recordRouting(), so no
-        // re-lowercase here (saves N allocations per inbound message).
-        const patternLower = pref.pattern;
-        if (words.some((word) => patternLower.includes(word) || word.includes(patternLower))) {
-            return { projectName: pref.project_name, confidence: Math.min(pref.confidence, 0.9) };
-        }
-    }
-    return null;
-}
-/**
- * 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 async function resolveProjectRoute(rawPrompt, tabName, text, userId) {
-    if (tabName !== 'default' || text.startsWith('/tab ')) {
-        return { effectiveTabName: tabName };
-    }
-    try {
-        const decision = routeMessage(rawPrompt, { userId });
-        if (decision.needsConfirmation) {
-            const projects = listProjects().filter((p) => p.type === 'user-project');
-            const options = projects.map((p, i) => `${i + 1}) ${p.name}`).join('\n');
-            return {
-                effectiveTabName: tabName,
-                confirmationMessage: `Which project?\n${options}\n\nReply with the number, or just send your message with /project <name> first.`,
-            };
-        }
-        setUserContext(userId, decision.project.name, decision.tabName);
-        return {
-            effectiveTabName: decision.tabName,
-            projectPath: decision.project.path,
-        };
-    }
-    catch {
-        return { effectiveTabName: tabName };
-    }
-}

package/dist/projects/types.d.ts

@@ -1,19 +0,0 @@
-export interface Project {
-    id: string;
-    name: string;
-    path: string;
-    type: 'user-project' | 'category';
-    lastUsedAt: string;
-    createdAt: string;
-}
-export interface RouteDecision {
-    project: Project;
-    tabName: string;
-    isNewTab: boolean;
-    confidence: number;
-    needsConfirmation: boolean;
-    reason: string;
-}
-export interface RoutingContext {
-    userId?: string;
-}

package/dist/projects/types.js

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

package/dist/service/install.d.ts

@@ -1,4 +0,0 @@
-export declare function installService(): string;
-export declare function uninstallService(): string;
-export declare function startService(): void;
-export declare function stopService(): void;

package/dist/service/install.js

@@ -1,146 +0,0 @@
-import fs from 'node:fs';
-import path from 'node:path';
-import { execSync } from 'node:child_process';
-import { getPlatform } from '../util/platform.js';
-import { ensureBeecorkDirs } from '../util/paths.js';
-import { getLaunchdPlist, getSystemdUnit, getLaunchdPlistPath, getSystemdUnitPath, } from './templates.js';
-import { installWindowsService, startWindowsService, stopWindowsService, uninstallWindowsService, } from './windows.js';
-function findNodePath() {
-    try {
-        const cmd = process.platform === 'win32' ? 'where node' : 'which node';
-        return execSync(cmd, { encoding: 'utf-8' }).trim().split(/\r?\n/)[0];
-    }
-    catch {
-        return process.platform === 'win32' ? 'node' : '/usr/local/bin/node';
-    }
-}
-function findDaemonPath() {
-    // import.meta.url is dist/service/install.js — daemon is at dist/daemon.js (one level up)
-    const thisFileUrl = new URL(import.meta.url);
-    const thisFile = process.platform === 'win32'
-        ? thisFileUrl.pathname.replace(/^\/([A-Za-z]:)/, '$1') // strip leading / on Windows drive paths
-        : thisFileUrl.pathname;
-    const distDir = path.dirname(path.dirname(thisFile)); // go up from service/ to dist/
-    const daemonPath = path.join(distDir, 'daemon.js');
-    if (fs.existsSync(daemonPath))
-        return daemonPath;
-    // Fallback: maybe we're in src/ during development
-    const srcDaemon = path.resolve(distDir, '..', 'dist', 'daemon.js');
-    if (fs.existsSync(srcDaemon))
-        return srcDaemon;
-    throw new Error('Could not find daemon.js. Make sure beecork is built (npm run build).');
-}
-export function installService() {
-    ensureBeecorkDirs();
-    const platform = getPlatform();
-    const nodePath = findNodePath();
-    const daemonPath = findDaemonPath();
-    if (platform === 'windows') {
-        installWindowsService(`${nodePath}" "${daemonPath}`);
-        return 'Windows Task Scheduler';
-    }
-    else if (platform === 'mac') {
-        return installLaunchd(nodePath, daemonPath);
-    }
-    else {
-        return installSystemd(nodePath, daemonPath);
-    }
-}
-export function uninstallService() {
-    const platform = getPlatform();
-    if (platform === 'windows') {
-        uninstallWindowsService();
-        return 'Windows Task Scheduler';
-    }
-    else if (platform === 'mac') {
-        return uninstallLaunchd();
-    }
-    else {
-        return uninstallSystemd();
-    }
-}
-export function startService() {
-    const platform = getPlatform();
-    if (platform === 'windows') {
-        startWindowsService();
-    }
-    else if (platform === 'mac') {
-        const plistPath = getLaunchdPlistPath();
-        execSync(`launchctl load "${plistPath}"`, { stdio: 'inherit' });
-    }
-    else {
-        execSync('systemctl --user start beecork', { stdio: 'inherit' });
-    }
-}
-export function stopService() {
-    const platform = getPlatform();
-    if (platform === 'windows') {
-        stopWindowsService();
-    }
-    else if (platform === 'mac') {
-        const plistPath = getLaunchdPlistPath();
-        try {
-            execSync(`launchctl unload "${plistPath}"`, { stdio: 'inherit' });
-        }
-        catch {
-            /* not loaded */
-        }
-    }
-    else {
-        try {
-            execSync('systemctl --user stop beecork', { stdio: 'inherit' });
-        }
-        catch {
-            /* not running */
-        }
-    }
-}
-function installLaunchd(nodePath, daemonPath) {
-    const plistPath = getLaunchdPlistPath();
-    const plistDir = path.dirname(plistPath);
-    fs.mkdirSync(plistDir, { recursive: true });
-    const content = getLaunchdPlist(nodePath, daemonPath);
-    fs.writeFileSync(plistPath, content);
-    return plistPath;
-}
-function uninstallLaunchd() {
-    const plistPath = getLaunchdPlistPath();
-    try {
-        execSync(`launchctl unload "${plistPath}"`, { stdio: 'pipe' });
-    }
-    catch {
-        /* ok */
-    }
-    if (fs.existsSync(plistPath))
-        fs.unlinkSync(plistPath);
-    return plistPath;
-}
-function installSystemd(nodePath, daemonPath) {
-    const unitPath = getSystemdUnitPath();
-    const unitDir = path.dirname(unitPath);
-    fs.mkdirSync(unitDir, { recursive: true });
-    const content = getSystemdUnit(nodePath, daemonPath);
-    fs.writeFileSync(unitPath, content);
-    execSync('systemctl --user daemon-reload', { stdio: 'pipe' });
-    execSync('systemctl --user enable beecork', { stdio: 'pipe' });
-    return unitPath;
-}
-function uninstallSystemd() {
-    const unitPath = getSystemdUnitPath();
-    try {
-        execSync('systemctl --user disable beecork', { stdio: 'pipe' });
-    }
-    catch {
-        /* ok */
-    }
-    try {
-        execSync('systemctl --user stop beecork', { stdio: 'pipe' });
-    }
-    catch {
-        /* ok */
-    }
-    if (fs.existsSync(unitPath))
-        fs.unlinkSync(unitPath);
-    execSync('systemctl --user daemon-reload', { stdio: 'pipe' });
-    return unitPath;
-}

package/dist/service/templates.d.ts

@@ -1,4 +0,0 @@
-export declare function getLaunchdPlist(nodePath: string, daemonPath: string): string;
-export declare function getSystemdUnit(nodePath: string, daemonPath: string): string;
-export declare function getLaunchdPlistPath(): string;
-export declare function getSystemdUnitPath(): string;

package/dist/service/templates.js

@@ -1,52 +0,0 @@
-import os from 'node:os';
-export function getLaunchdPlist(nodePath, daemonPath) {
-    const home = os.homedir();
-    return `<?xml version="1.0" encoding="UTF-8"?>
-<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
-<plist version="1.0">
-<dict>
-    <key>Label</key>
-    <string>com.beecork.daemon</string>
-    <key>ProgramArguments</key>
-    <array>
-        <string>${nodePath}</string>
-        <string>${daemonPath}</string>
-    </array>
-    <key>RunAtLoad</key>
-    <true/>
-    <key>KeepAlive</key>
-    <true/>
-    <key>StandardOutPath</key>
-    <string>${home}/.beecork/logs/daemon.stdout.log</string>
-    <key>StandardErrorPath</key>
-    <string>${home}/.beecork/logs/daemon.stderr.log</string>
-    <key>EnvironmentVariables</key>
-    <dict>
-        <key>PATH</key>
-        <string>/usr/local/bin:/usr/bin:/bin:${home}/.local/bin:${home}/.nvm/versions/node/current/bin</string>
-        <key>HOME</key>
-        <string>${home}</string>
-    </dict>
-</dict>
-</plist>`;
-}
-export function getSystemdUnit(nodePath, daemonPath) {
-    return `[Unit]
-Description=Beecork - Claude Code always-on infrastructure
-After=network.target
-
-[Service]
-ExecStart=${nodePath} ${daemonPath}
-Restart=always
-RestartSec=5
-Environment=PATH=/usr/local/bin:/usr/bin:/bin:%h/.local/bin
-
-[Install]
-WantedBy=default.target`;
-}
-export function getLaunchdPlistPath() {
-    return `${os.homedir()}/Library/LaunchAgents/com.beecork.daemon.plist`;
-}
-export function getSystemdUnitPath() {
-    return `${os.homedir()}/.config/systemd/user/beecork.service`;
-}

package/dist/service/windows.d.ts

@@ -1,8 +0,0 @@
-/** Install Beecork as a Windows Task Scheduler task */
-export declare function installWindowsService(binPath: string): void;
-/** Start the Windows service */
-export declare function startWindowsService(): void;
-/** Stop the Windows service */
-export declare function stopWindowsService(): void;
-/** Uninstall the Windows service */
-export declare function uninstallWindowsService(): void;

package/dist/service/windows.js

@@ -1,59 +0,0 @@
-import fs from 'node:fs';
-import path from 'node:path';
-import { execSync } from 'node:child_process';
-const TASK_NAME = 'BeecorkDaemon';
-/** Install Beecork as a Windows Task Scheduler task */
-export function installWindowsService(binPath) {
-    const appData = process.env.APPDATA || path.join(process.env.USERPROFILE || '', 'AppData', 'Roaming');
-    const logPath = path.join(appData, '.beecork', 'logs', 'daemon.log');
-    // Ensure log directory exists
-    fs.mkdirSync(path.dirname(logPath), { recursive: true });
-    // Create a wrapper script that runs beecork daemon
-    const wrapperPath = path.join(appData, '.beecork', 'start-daemon.bat');
-    fs.writeFileSync(wrapperPath, `@echo off\r\n"${binPath}" daemon >> "${logPath}" 2>&1\r\n`);
-    try {
-        // Remove existing task if any
-        execSync(`schtasks /Delete /TN "${TASK_NAME}" /F 2>nul`, { stdio: 'ignore' });
-    }
-    catch { }
-    // Create scheduled task that runs at logon
-    execSync(`schtasks /Create /TN "${TASK_NAME}" /TR "${wrapperPath}" /SC ONLOGON /RL HIGHEST /F`, {
-        stdio: 'inherit',
-    });
-    console.log(`Windows service installed: ${TASK_NAME}`);
-    console.log('The daemon will start automatically when you log in.');
-}
-/** Start the Windows service */
-export function startWindowsService() {
-    try {
-        execSync(`schtasks /Run /TN "${TASK_NAME}"`, { stdio: 'inherit' });
-        console.log('Beecork daemon started.');
-    }
-    catch {
-        console.error('Failed to start. Run manually: beecork daemon');
-    }
-}
-/** Stop the Windows service */
-export function stopWindowsService() {
-    try {
-        execSync(`schtasks /End /TN "${TASK_NAME}"`, { stdio: 'inherit' });
-        console.log('Beecork daemon stopped.');
-    }
-    catch {
-        // Try killing the process directly
-        try {
-            execSync('taskkill /F /IM node.exe /FI "WINDOWTITLE eq beecork*"', { stdio: 'ignore' });
-        }
-        catch { }
-    }
-}
-/** Uninstall the Windows service */
-export function uninstallWindowsService() {
-    try {
-        execSync(`schtasks /Delete /TN "${TASK_NAME}" /F`, { stdio: 'inherit' });
-        console.log('Beecork service uninstalled.');
-    }
-    catch {
-        console.error('Failed to uninstall service.');
-    }
-}

package/dist/session/budget-guard.d.ts

@@ -1,20 +0,0 @@
-/**
- * Per-tab spend budget enforcement, extracted from TabManager.
- *
- * Pure function (with a tiny stateful wrapper) so it can be unit-tested without
- * a database or a running subprocess: feed in current spend + tab name, get a
- * decision back. The caller (TabManager.executeMessage) handles the side
- * effects (notify + early return).
- */
-export interface BudgetDecision {
-    allowed: boolean;
-    /** When allowed=false, the message to surface to the caller. */
-    reason?: string;
-    /** When the tab has crossed the 80% threshold, the warning text to notify. */
-    warning?: string;
-}
-export declare class BudgetGuard {
-    private maxBudgetUsd;
-    constructor(maxBudgetUsd: number | undefined);
-    check(currentSpend: number, tabName: string): BudgetDecision;
-}

package/dist/session/budget-guard.js

@@ -1,31 +0,0 @@
-/**
- * Per-tab spend budget enforcement, extracted from TabManager.
- *
- * Pure function (with a tiny stateful wrapper) so it can be unit-tested without
- * a database or a running subprocess: feed in current spend + tab name, get a
- * decision back. The caller (TabManager.executeMessage) handles the side
- * effects (notify + early return).
- */
-export class BudgetGuard {
-    maxBudgetUsd;
-    constructor(maxBudgetUsd) {
-        this.maxBudgetUsd = maxBudgetUsd;
-    }
-    check(currentSpend, tabName) {
-        if (!this.maxBudgetUsd)
-            return { allowed: true };
-        if (currentSpend >= this.maxBudgetUsd) {
-            return {
-                allowed: false,
-                reason: `Budget limit reached for tab "${tabName}": $${currentSpend.toFixed(2)} / $${this.maxBudgetUsd.toFixed(2)}`,
-            };
-        }
-        if (currentSpend >= this.maxBudgetUsd * 0.8) {
-            return {
-                allowed: true,
-                warning: `⚠️ Budget warning: tab "${tabName}" at $${currentSpend.toFixed(2)} / $${this.maxBudgetUsd.toFixed(2)} (80%)`,
-            };
-        }
-        return { allowed: true };
-    }
-}

package/dist/session/circuit-breaker.d.ts

@@ -1,19 +0,0 @@
-import type { CircuitBreakerConfig, StreamContentToolUse } from '../types.js';
-export type CircuitBreakerAction = 'ok' | 'warn' | 'notify' | 'break';
-export declare class CircuitBreaker {
-    private tabName;
-    private ring;
-    private ringHead;
-    private ringSize;
-    private config;
-    private tripped;
-    private warned;
-    private notified;
-    private readonly WARN_THRESHOLD;
-    private readonly NOTIFY_THRESHOLD;
-    constructor(tabName: string, config?: Partial<CircuitBreakerConfig>);
-    /** Record a tool call. Returns the action to take. */
-    recordToolCall(toolUse: StreamContentToolUse): CircuitBreakerAction;
-    reset(): void;
-    get isTripped(): boolean;
-}