beecork 1.7.0 → 2.0.0

package/dist/session/circuit-breaker.js

@@ -1,91 +0,0 @@
-import { logger } from '../util/logger.js';
-const DEFAULT_CONFIG = {
-    maxRepeats: 20,
-    windowSize: 30,
-};
-/**
- * Detects loops in claude tool-use streams using consecutive-identical-call
- * counting. The signature is a hash of the tool name + input — JSON.stringify
- * would be O(input-size) per call and a 50KB Write tool input would allocate
- * 50KB just to compare equality, so we use a quick-hash strategy that's
- * length-independent.
- */
-function hashSignature(toolUse) {
-    // FNV-1a 32-bit hash of the JSON repr — fast, collision-rare for short inputs.
-    // For correctness we only need equality (was this the same call as before),
-    // not reversibility, so a hash is sufficient.
-    const s = `${toolUse.name}:${JSON.stringify(toolUse.input)}`;
-    let h = 0x811c9dc5;
-    for (let i = 0; i < s.length; i++) {
-        h ^= s.charCodeAt(i);
-        h = Math.imul(h, 0x01000193);
-    }
-    return `${toolUse.name}#${(h >>> 0).toString(36)}`;
-}
-export class CircuitBreaker {
-    tabName;
-    // Ring buffer to avoid per-call array reslice
-    ring;
-    ringHead = 0;
-    ringSize = 0;
-    config;
-    tripped = false;
-    warned = false;
-    notified = false;
-    WARN_THRESHOLD = 5;
-    NOTIFY_THRESHOLD = 10;
-    constructor(tabName, config) {
-        this.tabName = tabName;
-        this.config = { ...DEFAULT_CONFIG, ...config };
-        this.ring = new Array(this.config.windowSize);
-    }
-    /** Record a tool call. Returns the action to take. */
-    recordToolCall(toolUse) {
-        if (this.tripped)
-            return 'break';
-        const signature = hashSignature(toolUse);
-        this.ring[this.ringHead] = signature;
-        this.ringHead = (this.ringHead + 1) % this.config.windowSize;
-        if (this.ringSize < this.config.windowSize)
-            this.ringSize++;
-        // Count consecutive identical signatures walking backwards from the last
-        // write. (ringHead points at the NEXT slot, so the most-recent is head-1.)
-        let repeatCount = 0;
-        for (let i = 0; i < this.ringSize; i++) {
-            const idx = (this.ringHead - 1 - i + this.config.windowSize) % this.config.windowSize;
-            if (this.ring[idx] === signature) {
-                repeatCount++;
-            }
-            else {
-                break;
-            }
-        }
-        if (repeatCount >= this.config.maxRepeats) {
-            logger.warn(`[${this.tabName}] Circuit breaker tripped: ${toolUse.name} repeated ${repeatCount} times`);
-            this.tripped = true;
-            return 'break';
-        }
-        if (repeatCount >= this.NOTIFY_THRESHOLD && !this.notified) {
-            logger.warn(`[${this.tabName}] Loop detected: ${toolUse.name} repeated ${repeatCount} times — notifying user`);
-            this.notified = true;
-            return 'notify';
-        }
-        if (repeatCount >= this.WARN_THRESHOLD && !this.warned) {
-            logger.info(`[${this.tabName}] Loop detected: ${toolUse.name} repeated ${repeatCount} times — warning`);
-            this.warned = true;
-            return 'warn';
-        }
-        return 'ok';
-    }
-    reset() {
-        this.ring.fill(undefined);
-        this.ringHead = 0;
-        this.ringSize = 0;
-        this.tripped = false;
-        this.warned = false;
-        this.notified = false;
-    }
-    get isTripped() {
-        return this.tripped;
-    }
-}

package/dist/session/context-compactor.d.ts

@@ -1,32 +0,0 @@
-/**
- * Context-window compaction: when Claude's context fills, summarize the
- * conversation, rotate to a fresh session, and continue with the summary as
- * the new system seed.
- *
- * Extracted from TabManager.executeMessage. Owns the recursion-depth limit
- * (MAX_DEPTH = 2) and the "fall back to original result" failure mode so
- * compaction errors degrade gracefully instead of orphaning the message.
- */
-import type Database from 'better-sqlite3';
-import type { SendResult } from './manager.js';
-import type { Tab } from '../types.js';
-export type NotifyFn = ((text: string) => Promise<void>) | null;
-export interface SendMessageFn {
-    (tabName: string, prompt: string, options?: {
-        onTextChunk?: (text: string) => void;
-        _compactionDepth?: number;
-    }): Promise<SendResult>;
-}
-export declare const ContextCompactor: {
-    MAX_DEPTH: number;
-    /**
-     * Compact and continue the session. Returns the continuation result if
-     * compaction succeeds, or the original result if anything goes wrong so the
-     * user always gets *something* back.
-     *
-     * Important: callers should always run `processNextInQueue` (or equivalent)
-     * after this resolves regardless of which path it took — the queue drain
-     * obligation does not depend on compaction success.
-     */
-    compact(tab: Tab, enrichedPrompt: string, originalResult: SendResult, onTextChunk: ((text: string) => void) | undefined, currentDepth: number, sendMessage: SendMessageFn, notify: NotifyFn, db: Database.Database): Promise<SendResult>;
-};

package/dist/session/context-compactor.js

@@ -1,45 +0,0 @@
-/**
- * Context-window compaction: when Claude's context fills, summarize the
- * conversation, rotate to a fresh session, and continue with the summary as
- * the new system seed.
- *
- * Extracted from TabManager.executeMessage. Owns the recursion-depth limit
- * (MAX_DEPTH = 2) and the "fall back to original result" failure mode so
- * compaction errors degrade gracefully instead of orphaning the message.
- */
-import { v4 as uuidv4 } from 'uuid';
-import { logger } from '../util/logger.js';
-export const ContextCompactor = {
-    MAX_DEPTH: 2,
-    /**
-     * Compact and continue the session. Returns the continuation result if
-     * compaction succeeds, or the original result if anything goes wrong so the
-     * user always gets *something* back.
-     *
-     * Important: callers should always run `processNextInQueue` (or equivalent)
-     * after this resolves regardless of which path it took — the queue drain
-     * obligation does not depend on compaction success.
-     */
-    async compact(tab, enrichedPrompt, originalResult, onTextChunk, currentDepth, sendMessage, notify, db) {
-        logger.info(`[${tab.name}] Compacting context (depth ${currentDepth + 1}/${ContextCompactor.MAX_DEPTH}) — requesting summary then restarting session`);
-        notify?.(`🔄 [${tab.name}] Context window full — compacting and continuing...`).catch((err) => logger.warn('Notify failed:', err));
-        try {
-            const summaryPrompt = 'Summarize your progress in this session concisely: completed steps, current state, remaining steps, and all important identifiers (file paths, URLs, variable names). Output ONLY the summary.';
-            const summaryResult = await sendMessage(tab.name, summaryPrompt, {
-                _compactionDepth: currentDepth + 1,
-            });
-            const newSessionId = uuidv4();
-            db.prepare('UPDATE tabs SET session_id = ? WHERE id = ?').run(newSessionId, tab.id);
-            logger.info(`[${tab.name}] Context compacted — new session ${newSessionId.slice(0, 8)}...`);
-            const continuationPrompt = `[CONTEXT RESTORED FROM PREVIOUS SESSION]\n${summaryResult.text}\n\n[Continue the original task: "${enrichedPrompt.slice(0, 500)}"]`;
-            return await sendMessage(tab.name, continuationPrompt, {
-                onTextChunk,
-                _compactionDepth: currentDepth + 1,
-            });
-        }
-        catch (err) {
-            logger.error(`[${tab.name}] Compaction failed:`, err);
-            return originalResult;
-        }
-    },
-};

package/dist/session/context-monitor.d.ts

@@ -1,15 +0,0 @@
-import type { StreamUsage } from '../types.js';
-export type ContextAction = 'ok' | 'warn' | 'checkpoint';
-export declare class ContextMonitor {
-    private tabName;
-    private cumulativeTokens;
-    private contextWindow;
-    private warned;
-    private checkpointed;
-    constructor(tabName: string, contextWindow?: number);
-    /** Record token usage from a StreamAssistant or StreamResult event. Returns action needed. */
-    recordUsage(usage: StreamUsage): ContextAction;
-    get tokenCount(): number;
-    get usageRatio(): number;
-    reset(): void;
-}

package/dist/session/context-monitor.js

@@ -1,44 +0,0 @@
-import { logger } from '../util/logger.js';
-const DEFAULT_CONTEXT_WINDOW = 200_000; // Claude's context window in tokens
-const WARNING_THRESHOLD = 0.8;
-const CHECKPOINT_THRESHOLD = 0.9;
-export class ContextMonitor {
-    tabName;
-    cumulativeTokens = 0;
-    contextWindow;
-    warned = false;
-    checkpointed = false;
-    constructor(tabName, contextWindow = DEFAULT_CONTEXT_WINDOW) {
-        this.tabName = tabName;
-        this.contextWindow = contextWindow;
-    }
-    /** Record token usage from a StreamAssistant or StreamResult event. Returns action needed. */
-    recordUsage(usage) {
-        // Only count input_tokens — this already includes cached tokens.
-        // output_tokens don't consume context window; cache subtypes are part of input_tokens.
-        this.cumulativeTokens += usage.input_tokens;
-        const ratio = this.cumulativeTokens / this.contextWindow;
-        if (ratio >= CHECKPOINT_THRESHOLD && !this.checkpointed) {
-            this.checkpointed = true;
-            logger.warn(`[${this.tabName}] Context at ${Math.round(ratio * 100)}% — checkpoint needed`);
-            return 'checkpoint';
-        }
-        if (ratio >= WARNING_THRESHOLD && !this.warned) {
-            this.warned = true;
-            logger.info(`[${this.tabName}] Context at ${Math.round(ratio * 100)}% — warning`);
-            return 'warn';
-        }
-        return 'ok';
-    }
-    get tokenCount() {
-        return this.cumulativeTokens;
-    }
-    get usageRatio() {
-        return this.cumulativeTokens / this.contextWindow;
-    }
-    reset() {
-        this.cumulativeTokens = 0;
-        this.warned = false;
-        this.checkpointed = false;
-    }
-}

package/dist/session/handoff.d.ts

@@ -1,21 +0,0 @@
-/**
- * Session handoff helpers — used by both the CLI (`beecork attach`) and the
- * shared command handler (`/handoff` from any channel).
- *
- * Moved here from `cli/handoff.ts` so daemon-shared code (channels, MCP) can
- * import without reaching into the CLI layer. The CLI-specific `attachTab`
- * (which spawns claude and calls process.exit) stays in `cli/handoff.ts`.
- */
-export interface TabHandoffInfo {
-    name: string;
-    sessionId: string;
-    workingDir: string;
-    status: string;
-    lastActivity: string;
-    recentMessages: Array<{
-        role: string;
-        content: string;
-    }>;
-}
-export declare function exportTab(tabName: string): TabHandoffInfo | null;
-export declare function formatHandoffInfo(info: TabHandoffInfo): string;

package/dist/session/handoff.js

@@ -1,50 +0,0 @@
-/**
- * Session handoff helpers — used by both the CLI (`beecork attach`) and the
- * shared command handler (`/handoff` from any channel).
- *
- * Moved here from `cli/handoff.ts` so daemon-shared code (channels, MCP) can
- * import without reaching into the CLI layer. The CLI-specific `attachTab`
- * (which spawns claude and calls process.exit) stays in `cli/handoff.ts`.
- */
-import { getDb } from '../db/index.js';
-import { TabStore } from './tab-store.js';
-export function exportTab(tabName) {
-    const tab = TabStore.findByName(tabName);
-    if (!tab)
-        return null;
-    const messages = getDb()
-        .prepare('SELECT role, content FROM messages WHERE tab_id = ? ORDER BY created_at DESC LIMIT 5')
-        .all(tab.id);
-    return {
-        name: tab.name,
-        sessionId: tab.sessionId,
-        workingDir: tab.workingDir,
-        status: tab.status,
-        lastActivity: tab.lastActivityAt,
-        recentMessages: messages.reverse(),
-    };
-}
-export function formatHandoffInfo(info) {
-    const lines = [
-        `Session Handoff — tab "${info.name}"`,
-        '',
-        `Session ID: ${info.sessionId}`,
-        `Working dir: ${info.workingDir}`,
-        `Status: ${info.status}`,
-        `Last activity: ${info.lastActivity}`,
-        '',
-        'To resume in terminal:',
-        `  beecork attach ${info.name}`,
-        '',
-        'Or manually:',
-        `  cd ${info.workingDir}`,
-        `  claude --session-id ${info.sessionId} --resume`,
-    ];
-    if (info.recentMessages.length > 0) {
-        lines.push('', 'Recent context:');
-        for (const msg of info.recentMessages) {
-            lines.push(`  [${msg.role}] ${msg.content.slice(0, 150)}${msg.content.length > 150 ? '...' : ''}`);
-        }
-    }
-    return lines.join('\n');
-}

package/dist/session/manager.d.ts

@@ -1,60 +0,0 @@
-import type { BeecorkConfig, Tab } from '../types.js';
-export type { StreamResult } from '../types.js';
-export interface SendResult {
-    text: string;
-    costUsd: number;
-    durationMs: number;
-    sessionId: string;
-    error: boolean;
-}
-export type NotifyCallback = (text: string) => Promise<void>;
-/**
- * TabManager orchestrates per-tab Claude subprocess lifecycles. Heavy lifting
- * (queueing, budget enforcement, stale-session recovery, context compaction,
- * pending-message dispatch) is delegated to collaborators in this directory
- * so this class stays focused on:
- *
- *   - tab CRUD (ensureTab, listTabs, stopTab, closeTab, stopAll)
- *   - subprocess orchestration (executeMessage)
- *   - wiring the collaborators together
- *
- * The split happened in the 2026-05-15 audit fix; see the audit file for the
- * rationale. Before the split this file was 467 lines and 10 responsibilities.
- */
-export declare class TabManager {
-    private config;
-    private subprocesses;
-    private queue;
-    private budget;
-    private tabCostCache;
-    private onNotify;
-    constructor(config: BeecorkConfig);
-    /** Set a callback for sending notifications (e.g., via Telegram) */
-    setNotifyCallback(cb: NotifyCallback): void;
-    /** Ensure a tab exists in the database. Creates it if missing. */
-    ensureTab(tabName: string, workingDirOverride?: string): Tab;
-    /** Send a message to a tab. Creates the tab if it doesn't exist. Queues if busy. */
-    sendMessage(tabName: string, prompt: string, options?: {
-        resume?: boolean;
-        onTextChunk?: (text: string) => void;
-        onToolUse?: (toolName: string, toolInput: Record<string, unknown>) => void;
-        projectPath?: string;
-        _compactionDepth?: number;
-    }): Promise<SendResult>;
-    /** Get all tabs from the database */
-    listTabs(): Tab[];
-    /** Get a specific tab */
-    getTab(tabName: string): Tab | undefined;
-    /** Stop a tab's running subprocess */
-    stopTab(tabName: string): void;
-    /** Update a tab's system_prompt. Returns true if the tab existed. */
-    setSystemPrompt(tabName: string, systemPrompt: string): boolean;
-    /** Close a tab — stop subprocess and delete its rows. Returns true if the tab existed. */
-    closeTab(tabName: string): boolean;
-    /** Stop all running subprocesses (clean shutdown) */
-    stopAll(): void;
-    private executeMessage;
-    private processNextInQueue;
-    private updateTabStatus;
-    private clearQueue;
-}