beecork 1.3.11 → 1.4.1

package/dist/pipe/brain.js

@@ -1,160 +0,0 @@
-import { PipeAnthropicClient } from './anthropic-client.js';
-import { PipeMemoryStore } from './memory-store.js';
-import { scanForProjects } from './project-scanner.js';
-import { parseTabMessage } from '../util/text.js';
-import { logger } from '../util/logger.js';
-export class PipeBrain {
-    client;
-    memory;
-    config;
-    tabManager;
-    notifyCallback = null;
-    constructor(config, tabManager) {
-        this.config = config;
-        this.tabManager = tabManager;
-        this.client = new PipeAnthropicClient(config.pipe.anthropicApiKey, config.pipe.routingModel, config.pipe.complexModel);
-        this.memory = new PipeMemoryStore();
-    }
-    setNotifyCallback(cb) {
-        this.notifyCallback = cb;
-    }
-    /** Main entry point: process a user message with intelligence */
-    async process(message, context) {
-        const decisions = [];
-        // Step 1: Route the message to the right tab/project
-        const route = await this.route(message, decisions);
-        // Step 2: Ensure the tab exists with the right working directory
-        if (route.projectPath) {
-            this.tabManager.ensureTab(route.tabName, route.projectPath);
-            this.memory.updateProjectLastUsed(route.projectPath);
-        }
-        // Step 3: Send to Claude Code
-        let result;
-        try {
-            result = await this.tabManager.sendMessage(route.tabName, message, { skipExtraction: true, projectPath: route.projectPath ?? undefined });
-        }
-        catch (err) {
-            return {
-                tabName: route.tabName,
-                response: { text: `Error: ${err instanceof Error ? err.message : err}`, error: true, costUsd: 0, durationMs: 0 },
-                decisions,
-                goalStatus: null,
-            };
-        }
-        // Step 4: Evaluate if the goal was achieved
-        let goalStatus = null;
-        if (!result.error && result.text && result.durationMs > 3000) {
-            goalStatus = await this.evaluateAndFollowUp(message, result, route.tabName, decisions);
-        }
-        // Step 5: Learn from the conversation (fire and forget)
-        this.learn(route.tabName, message, result.text).catch(err => {
-            logger.error('Pipe learning failed:', err);
-        });
-        return {
-            tabName: route.tabName,
-            response: { text: result.text, error: result.error, costUsd: result.costUsd, durationMs: result.durationMs },
-            decisions,
-            goalStatus,
-        };
-    }
-    /** Route a message to the right project/tab */
-    async route(message, decisions) {
-        // Check for manual /tab override first
-        if (message.startsWith('/tab ')) {
-            const parsed = parseTabMessage(message);
-            if (parsed.tabName !== 'default') {
-                decisions.push(`📌 Manual routing to "${parsed.tabName}"`);
-                return { tabName: parsed.tabName, projectPath: null, confidence: 1.0, reason: 'Manual override', needsConfirmation: false };
-            }
-        }
-        const projects = this.memory.getProjects();
-        const recentRouting = this.memory.getRecentRouting(5);
-        // If no projects and no API key, just use default
-        if (projects.length === 0 || !this.config.pipe.anthropicApiKey) {
-            decisions.push('📍 Routing to default tab (no projects discovered)');
-            return { tabName: 'default', projectPath: null, confidence: 1.0, reason: 'No projects', needsConfirmation: false };
-        }
-        try {
-            const route = await this.client.route(message, projects, recentRouting);
-            // Record the routing decision
-            this.memory.recordRouting(message, route.tabName, route.projectPath, route.confidence);
-            if (route.confidence >= this.config.pipe.confidenceThreshold) {
-                decisions.push(`🧠 Routing to "${route.tabName}" (${Math.round(route.confidence * 100)}% confidence) — ${route.reason}`);
-            }
-            else {
-                decisions.push(`🤔 Low confidence routing to "${route.tabName}" (${Math.round(route.confidence * 100)}%) — ${route.reason}. Using default.`);
-                route.tabName = 'default';
-            }
-            return route;
-        }
-        catch (err) {
-            logger.error('Pipe routing failed, using default:', err);
-            decisions.push('⚠️ Routing failed, using default tab');
-            return { tabName: 'default', projectPath: null, confidence: 0.5, reason: 'Routing error', needsConfirmation: false };
-        }
-    }
-    /** Evaluate if the goal was achieved and send follow-ups if needed */
-    async evaluateAndFollowUp(originalGoal, lastResult, tabName, decisions) {
-        let currentResult = lastResult;
-        let followUpCount = 0;
-        const maxFollowUps = this.config.pipe.maxFollowUps;
-        while (followUpCount < maxFollowUps) {
-            try {
-                const evaluation = await this.client.evaluateGoal(originalGoal, currentResult.text);
-                if (evaluation.status === 'done') {
-                    decisions.push(`✅ Goal achieved: ${evaluation.reason}`);
-                    return evaluation;
-                }
-                if (evaluation.status === 'failed') {
-                    decisions.push(`❌ Goal failed: ${evaluation.reason}`);
-                    return evaluation;
-                }
-                // PARTIAL — send follow-up
-                followUpCount++;
-                const followUpMsg = evaluation.followUp || `Continue working on the original goal: "${originalGoal}". You haven't finished yet.`;
-                decisions.push(`🔄 Follow-up ${followUpCount}/${maxFollowUps}: ${evaluation.reason}`);
-                // Notify user about the follow-up
-                await this.notifyCallback?.(`🔄 [${tabName}] Sending follow-up (${followUpCount}/${maxFollowUps}): ${evaluation.reason}`);
-                // Send follow-up to Claude Code
-                currentResult = await this.tabManager.sendMessage(tabName, followUpMsg);
-                if (currentResult.error) {
-                    decisions.push(`❌ Follow-up failed with error`);
-                    return { status: 'failed', reason: currentResult.text, followUp: null };
-                }
-            }
-            catch (err) {
-                logger.error('Goal evaluation failed:', err);
-                return { status: 'done', reason: 'Evaluation error — assuming done', followUp: null };
-            }
-        }
-        decisions.push(`⚠️ Max follow-ups (${maxFollowUps}) reached`);
-        return { status: 'partial', reason: `Reached max ${maxFollowUps} follow-ups`, followUp: null };
-    }
-    /** Learn from a completed conversation */
-    async learn(tabName, userMessage, response) {
-        if (!response || response.length < 100)
-            return;
-        try {
-            const existingFacts = this.memory.getKnowledge('', 10);
-            const entries = await this.client.extractKnowledge(`User: ${userMessage}\n\nAssistant: ${response}`, existingFacts);
-            for (const entry of entries) {
-                entry.tabName = tabName;
-                this.memory.addKnowledge(entry);
-            }
-            if (entries.length > 0) {
-                logger.info(`Pipe learned ${entries.length} facts from ${tabName}`);
-            }
-        }
-        catch (err) {
-            logger.error('Pipe learning error:', err);
-        }
-    }
-    /** Discover projects on the filesystem */
-    async discoverProjects() {
-        const projects = scanForProjects(this.config.pipe.projectScanPaths);
-        for (const project of projects) {
-            this.memory.upsertProject(project);
-        }
-        return projects.length;
-    }
-}

package/dist/pipe/memory-store.d.ts

@@ -1,10 +0,0 @@
-import type { Project, KnowledgeEntry } from './types.js';
-export declare class PipeMemoryStore {
-    getProjects(): Project[];
-    upsertProject(project: Project): void;
-    updateProjectLastUsed(path: string): void;
-    getRecentRouting(limit?: number): string[];
-    recordRouting(messagePreview: string, tabName: string, projectPath: string | null, confidence: number): void;
-    addKnowledge(entry: KnowledgeEntry): void;
-    getKnowledge(query: string, limit?: number): string[];
-}

package/dist/pipe/memory-store.js

@@ -1,50 +0,0 @@
-import { v4 as uuidv4 } from 'uuid';
-import { getDb } from '../db/index.js';
-export class PipeMemoryStore {
-    // ─── Projects ───
-    getProjects() {
-        const db = getDb();
-        const rows = db.prepare('SELECT * FROM projects ORDER BY last_used_at DESC NULLS LAST').all();
-        return rows.map(r => ({
-            id: r.id,
-            name: r.name,
-            path: r.path,
-            type: r.type || 'user-project',
-            lastUsedAt: r.last_used_at,
-            createdAt: r.created_at,
-        }));
-    }
-    upsertProject(project) {
-        const db = getDb();
-        db.prepare(`INSERT INTO projects (id, name, path, type)
-      VALUES (?, ?, ?, ?)
-      ON CONFLICT(name) DO UPDATE SET
-        path=excluded.path, type=excluded.type, last_used_at=datetime('now')
-    `).run(project.id || uuidv4(), project.name, project.path, project.type || 'user-project');
-    }
-    updateProjectLastUsed(path) {
-        const db = getDb();
-        db.prepare('UPDATE projects SET last_used_at = datetime("now") WHERE path = ?').run(path);
-    }
-    // ─── Routing History ───
-    getRecentRouting(limit = 10) {
-        const db = getDb();
-        const rows = db.prepare('SELECT message_preview, tab_name, confidence FROM routing_history ORDER BY created_at DESC LIMIT ?').all(limit);
-        return rows.map(r => `"${r.message_preview}" → ${r.tab_name} (${Math.round(r.confidence * 100)}%)`);
-    }
-    recordRouting(messagePreview, tabName, projectPath, confidence) {
-        const db = getDb();
-        db.prepare('INSERT INTO routing_history (message_preview, tab_name, project_path, confidence) VALUES (?, ?, ?, ?)').run(messagePreview.slice(0, 200), tabName, projectPath, confidence);
-    }
-    // ─── Knowledge ───
-    addKnowledge(entry) {
-        const db = getDb();
-        const content = entry.category ? `[${entry.category}] ${entry.content}` : entry.content;
-        db.prepare('INSERT INTO memories (content, tab_name, source) VALUES (?, ?, ?)').run(content, entry.tabName, entry.source);
-    }
-    getKnowledge(query, limit = 20) {
-        const db = getDb();
-        const rows = db.prepare('SELECT content FROM memories WHERE content LIKE ? ORDER BY created_at DESC LIMIT ?').all(`%${query}%`, limit);
-        return rows.map(r => r.content);
-    }
-}

package/dist/pipe/project-scanner.d.ts

@@ -1,6 +0,0 @@
-import type { Project } from './types.js';
-/**
- * Read projects from the database (populated by discoverProjects() at daemon startup).
- * Falls back to an empty list if the DB is not yet initialized.
- */
-export declare function scanForProjects(_scanPaths: string[]): Project[];

package/dist/pipe/project-scanner.js

@@ -1,26 +0,0 @@
-import { getDb } from '../db/index.js';
-import { logger } from '../util/logger.js';
-/**
- * Read projects from the database (populated by discoverProjects() at daemon startup).
- * Falls back to an empty list if the DB is not yet initialized.
- */
-export function scanForProjects(_scanPaths) {
-    try {
-        const db = getDb();
-        const rows = db.prepare('SELECT * FROM projects ORDER BY last_used_at DESC').all();
-        const projects = rows.map(r => ({
-            id: r.id,
-            name: r.name,
-            path: r.path,
-            type: r.type,
-            lastUsedAt: r.last_used_at,
-            createdAt: r.created_at,
-        }));
-        logger.info(`Project scanner: found ${projects.length} projects from DB`);
-        return projects;
-    }
-    catch (err) {
-        logger.warn('Project scanner: failed to read from DB, returning empty list:', err);
-        return [];
-    }
-}

package/dist/pipe/types.d.ts

@@ -1,46 +0,0 @@
-export interface Project {
-    id: string;
-    name: string;
-    path: string;
-    type: string;
-    lastUsedAt: string;
-    createdAt: string;
-    /** Populated at scan time, not persisted in DB */
-    description?: string;
-    /** Populated at scan time, not persisted in DB */
-    languages?: string[];
-}
-export interface RouteDecision {
-    tabName: string;
-    projectPath: string | null;
-    confidence: number;
-    reason: string;
-    needsConfirmation: boolean;
-}
-export interface GoalEvaluation {
-    status: 'done' | 'partial' | 'failed';
-    reason: string;
-    followUp: string | null;
-}
-export interface KnowledgeEntry {
-    content: string;
-    category: 'project' | 'preference' | 'decision' | 'fact';
-    tabName: string | null;
-    source: 'scan' | 'conversation' | 'user' | 'pipe';
-}
-export interface ChatContext {
-    chatId: number;
-    userId: number;
-    messageId: number;
-}
-export interface PipeResult {
-    tabName: string;
-    response: {
-        text: string;
-        error: boolean;
-        costUsd: number;
-        durationMs: number;
-    };
-    decisions: string[];
-    goalStatus: GoalEvaluation | null;
-}

package/dist/pipe/types.js

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