beecork 1.7.0 → 2.0.0

package/dist/db/migrations.js

@@ -1,384 +0,0 @@
-import { logger } from '../util/logger.js';
-/*
- * Migration authoring conventions:
- *
- * - Every migration runs inside a single transaction so partial failures are
- *   atomically rolled back. Idempotency checks for ALTER TABLE ADD/DROP COLUMN
- *   are performed inline below.
- *
- * - For destructive reshapes (column type change, rename, etc.) follow the
- *   SQLite-recommended pattern, all in one migration so the transaction wraps
- *   it cleanly:
- *
- *     CREATE TABLE new_X (...);
- *     INSERT INTO new_X (a, b, c) SELECT a, b, c FROM X;
- *     DROP TABLE X;
- *     ALTER TABLE new_X RENAME TO X;
- *
- *   AVOID `DROP TABLE X; CREATE TABLE X (...)` without a copy step — migration
- *   v13 did this and silently nuked user-created rows. The audit history flags
- *   that as a one-off; do not repeat it.
- */
-const MIGRATIONS = [
-    {
-        version: 2,
-        description: 'Add user_id column for multi-user support',
-        up: `
-      ALTER TABLE tabs ADD COLUMN user_id TEXT NOT NULL DEFAULT 'local';
-      ALTER TABLE memories ADD COLUMN user_id TEXT NOT NULL DEFAULT 'local';
-    `,
-    },
-    {
-        version: 3,
-        description: 'Add schema_version table',
-        up: '', // Already handled by bootstrap
-    },
-    {
-        version: 4,
-        description: 'Add cron_jobs table in SQLite',
-        up: `
-      CREATE TABLE IF NOT EXISTS cron_jobs (
-        id TEXT PRIMARY KEY,
-        name TEXT NOT NULL,
-        schedule_type TEXT NOT NULL,
-        schedule TEXT NOT NULL,
-        tab_name TEXT NOT NULL DEFAULT 'default',
-        message TEXT NOT NULL,
-        enabled INTEGER NOT NULL DEFAULT 1,
-        user_id TEXT NOT NULL DEFAULT 'local',
-        created_at TEXT NOT NULL DEFAULT (datetime('now')),
-        last_run_at TEXT,
-        next_run_at TEXT
-      );
-      CREATE INDEX IF NOT EXISTS idx_cron_jobs_user ON cron_jobs(user_id, enabled);
-    `,
-    },
-    {
-        version: 5,
-        description: 'Add type column to pending_messages for notifications',
-        up: `
-      ALTER TABLE pending_messages ADD COLUMN type TEXT NOT NULL DEFAULT 'message';
-      ALTER TABLE pending_messages ADD COLUMN user_id TEXT NOT NULL DEFAULT 'local';
-    `,
-    },
-    {
-        version: 6,
-        description: 'Add pipe intelligence tables (projects, preferences, permissions, routing)',
-        up: `
-      CREATE TABLE IF NOT EXISTS projects (
-        id TEXT PRIMARY KEY,
-        name TEXT NOT NULL,
-        path TEXT UNIQUE NOT NULL,
-        description TEXT DEFAULT '',
-        languages TEXT DEFAULT '[]',
-        last_used TEXT,
-        tab_name TEXT,
-        discovered_via TEXT DEFAULT 'scan',
-        created_at TEXT DEFAULT (datetime('now')),
-        updated_at TEXT DEFAULT (datetime('now'))
-      );
-      CREATE INDEX IF NOT EXISTS idx_projects_path ON projects(path);
-      CREATE INDEX IF NOT EXISTS idx_projects_name ON projects(name);
-
-      CREATE TABLE IF NOT EXISTS preferences (
-        key TEXT PRIMARY KEY,
-        value TEXT NOT NULL,
-        updated_at TEXT DEFAULT (datetime('now'))
-      );
-
-      CREATE TABLE IF NOT EXISTS permission_history (
-        id INTEGER PRIMARY KEY AUTOINCREMENT,
-        tool_name TEXT NOT NULL,
-        tool_args_pattern TEXT NOT NULL,
-        decision TEXT NOT NULL,
-        confidence REAL DEFAULT 1.0,
-        context TEXT,
-        tab_name TEXT,
-        created_at TEXT DEFAULT (datetime('now'))
-      );
-      CREATE INDEX IF NOT EXISTS idx_permissions_tool ON permission_history(tool_name, created_at);
-
-      CREATE TABLE IF NOT EXISTS routing_history (
-        id INTEGER PRIMARY KEY AUTOINCREMENT,
-        message_preview TEXT NOT NULL,
-        tab_name TEXT NOT NULL,
-        project_path TEXT,
-        confidence REAL NOT NULL,
-        was_correct INTEGER,
-        created_at TEXT DEFAULT (datetime('now'))
-      );
-      CREATE INDEX IF NOT EXISTS idx_routing_tab ON routing_history(tab_name, created_at);
-    `,
-    },
-    {
-        version: 7,
-        description: 'Add delivery tracking columns to messages',
-        up: `ALTER TABLE messages ADD COLUMN delivery_status TEXT DEFAULT 'sent';
-         ALTER TABLE messages ADD COLUMN retry_count INTEGER DEFAULT 0;`,
-    },
-    {
-        version: 8,
-        description: 'Add system_prompt column to tabs',
-        up: 'ALTER TABLE tabs ADD COLUMN system_prompt TEXT DEFAULT NULL',
-    },
-    {
-        version: 9,
-        description: 'Add users table',
-        up: `CREATE TABLE IF NOT EXISTS users (
-      id TEXT PRIMARY KEY,
-      name TEXT NOT NULL,
-      role TEXT NOT NULL DEFAULT 'user',
-      budget_usd REAL,
-      created_at TEXT DEFAULT (datetime('now'))
-    )`,
-    },
-    {
-        version: 10,
-        description: 'Add identities table for cross-channel identity',
-        up: `CREATE TABLE IF NOT EXISTS identities (
-      id INTEGER PRIMARY KEY AUTOINCREMENT,
-      user_id TEXT NOT NULL REFERENCES users(id),
-      channel_id TEXT NOT NULL,
-      peer_id TEXT NOT NULL,
-      created_at TEXT DEFAULT (datetime('now')),
-      UNIQUE(channel_id, peer_id)
-    )`,
-    },
-    {
-        version: 11,
-        description: 'Add delegations table for multi-agent orchestration',
-        up: `CREATE TABLE IF NOT EXISTS delegations (
-      id TEXT PRIMARY KEY,
-      source_tab TEXT NOT NULL,
-      target_tab TEXT NOT NULL,
-      message TEXT NOT NULL,
-      return_to_tab TEXT,
-      status TEXT NOT NULL DEFAULT 'pending',
-      result TEXT,
-      depth INTEGER NOT NULL DEFAULT 0,
-      created_at TEXT DEFAULT (datetime('now')),
-      completed_at TEXT
-    )`,
-    },
-    {
-        version: 12,
-        description: 'Removed machines table (retired multi-machine scaffolding)',
-        up: '',
-    },
-    {
-        // NOTE: this migration is destructive — any user-created project rows from
-        // before v13 are lost. discoverProjects() repopulates the table on next
-        // daemon start, so in practice only manually-created projects are affected.
-        // Future destructive migrations should copy data into the new shape instead.
-        version: 13,
-        description: 'Recreate projects table with new schema (DESTRUCTIVE — see comment)',
-        up: `DROP TABLE IF EXISTS projects;
-    CREATE TABLE IF NOT EXISTS projects (
-      id TEXT PRIMARY KEY,
-      name TEXT UNIQUE NOT NULL,
-      path TEXT NOT NULL,
-      type TEXT NOT NULL DEFAULT 'user-project',
-      last_used_at TEXT DEFAULT (datetime('now')),
-      created_at TEXT DEFAULT (datetime('now'))
-    )`,
-    },
-    {
-        version: 14,
-        description: 'Add routing_preferences table',
-        up: `CREATE TABLE IF NOT EXISTS routing_preferences (
-      id INTEGER PRIMARY KEY AUTOINCREMENT,
-      pattern TEXT NOT NULL,
-      project_name TEXT NOT NULL,
-      confidence REAL DEFAULT 1.0,
-      hit_count INTEGER DEFAULT 1,
-      created_at TEXT DEFAULT (datetime('now'))
-    )`,
-    },
-    {
-        version: 15,
-        description: 'Add project_id to tabs',
-        up: 'ALTER TABLE tabs ADD COLUMN project_id TEXT DEFAULT NULL',
-    },
-    {
-        version: 16,
-        description: 'Add payload_type to cron_jobs + routing pattern index',
-        up: `ALTER TABLE cron_jobs ADD COLUMN payload_type TEXT DEFAULT 'agentTurn';
-         CREATE UNIQUE INDEX IF NOT EXISTS idx_routing_pattern ON routing_preferences(pattern, project_name);`,
-    },
-    {
-        version: 17,
-        description: 'Add index on messages.created_at for date-range cost queries',
-        up: 'CREATE INDEX IF NOT EXISTS idx_messages_created_at ON messages(created_at)',
-    },
-    {
-        version: 18,
-        description: 'Rename cron_jobs table to tasks',
-        up: 'ALTER TABLE cron_jobs RENAME TO tasks',
-    },
-    {
-        version: 19,
-        description: 'Add watchers table',
-        up: `CREATE TABLE IF NOT EXISTS watchers (
-      id TEXT PRIMARY KEY,
-      name TEXT NOT NULL,
-      description TEXT,
-      check_command TEXT NOT NULL,
-      condition TEXT NOT NULL,
-      action TEXT NOT NULL DEFAULT 'notify',
-      action_details TEXT,
-      schedule TEXT NOT NULL,
-      last_check_at TEXT,
-      last_triggered_at TEXT,
-      trigger_count INTEGER DEFAULT 0,
-      enabled INTEGER DEFAULT 1,
-      created_at TEXT DEFAULT (datetime('now'))
-    )`,
-    },
-    {
-        version: 20,
-        description: 'Add activity_log table for timeline',
-        up: `CREATE TABLE IF NOT EXISTS activity_log (
-      id TEXT PRIMARY KEY,
-      event_type TEXT NOT NULL,
-      project_name TEXT,
-      tab_name TEXT,
-      summary TEXT NOT NULL,
-      details TEXT,
-      duration_ms INTEGER,
-      cost_usd REAL,
-      created_at TEXT DEFAULT (datetime('now'))
-    )`,
-    },
-    {
-        version: 21,
-        description: 'Add index on activity_log.created_at',
-        up: 'CREATE INDEX IF NOT EXISTS idx_activity_log_created ON activity_log(created_at)',
-    },
-    {
-        version: 22,
-        description: 'Add indices on memories for dedup lookups and tab-scoped reads',
-        up: `
-      CREATE INDEX IF NOT EXISTS idx_memories_content ON memories(content);
-      CREATE INDEX IF NOT EXISTS idx_memories_tab_name ON memories(tab_name, created_at);
-    `,
-    },
-    {
-        version: 23,
-        description: 'Index routing_preferences.hit_count for fast WHERE/ORDER BY in routing hot path',
-        up: 'CREATE INDEX IF NOT EXISTS idx_routing_prefs_hits ON routing_preferences(hit_count DESC)',
-    },
-    {
-        version: 24,
-        description: 'Rip out multi-user scaffolding (never enforced; everything was hardcoded user_id="local")',
-        up: `
-      DROP TABLE IF EXISTS identities;
-      DROP TABLE IF EXISTS users;
-      DROP INDEX IF EXISTS idx_cron_jobs_user;
-      ALTER TABLE tabs DROP COLUMN user_id;
-      ALTER TABLE memories DROP COLUMN user_id;
-      ALTER TABLE tasks DROP COLUMN user_id;
-      ALTER TABLE pending_messages DROP COLUMN user_id;
-    `,
-    },
-    {
-        version: 25,
-        description: 'Drop idx_memories_content — leading-wildcard LIKE cannot use a B-tree index',
-        up: 'DROP INDEX IF EXISTS idx_memories_content',
-    },
-    {
-        version: 26,
-        description: 'Add status column to pending_messages for 3-state lifecycle (pending → processing → done|failed); allow nullable tab_name for notifications',
-        up: `
-      ALTER TABLE pending_messages ADD COLUMN status TEXT NOT NULL DEFAULT 'pending';
-      UPDATE pending_messages SET status = 'done' WHERE processed = 1;
-      UPDATE pending_messages SET status = 'pending' WHERE processed = 0;
-      CREATE INDEX IF NOT EXISTS idx_pending_status_created ON pending_messages(status, created_at);
-    `,
-    },
-    {
-        version: 27,
-        description: 'Add indexes for delegations (source_tab, target_tab) to prevent scans on completion lookup',
-        up: `
-      CREATE INDEX IF NOT EXISTS idx_delegations_source ON delegations(source_tab, status);
-      CREATE INDEX IF NOT EXISTS idx_delegations_target ON delegations(target_tab, status, created_at);
-    `,
-    },
-    {
-        version: 28,
-        description: 'Add idx_tabs_working_dir for the per-message routing query that finds tabs by project path',
-        up: 'CREATE INDEX IF NOT EXISTS idx_tabs_working_dir ON tabs(working_dir, last_activity_at)',
-    },
-];
-export function runMigrations(db) {
-    // Ensure schema_version table exists
-    db.exec(`
-    CREATE TABLE IF NOT EXISTS schema_version (
-      version INTEGER NOT NULL DEFAULT 1
-    );
-  `);
-    // Get current version
-    let row = db.prepare('SELECT version FROM schema_version').get();
-    if (!row) {
-        db.prepare('INSERT INTO schema_version (version) VALUES (?)').run(1);
-        row = { version: 1 };
-    }
-    const currentVersion = row.version;
-    // Apply pending migrations
-    for (const migration of MIGRATIONS) {
-        if (migration.version <= currentVersion)
-            continue;
-        if (!migration.up) {
-            db.prepare('UPDATE schema_version SET version = ?').run(migration.version);
-            continue;
-        }
-        logger.info(`DB migration v${migration.version}: ${migration.description}`);
-        // Split multi-statement migrations and apply each safely
-        // (handles partial failures from previous runs where some statements succeeded)
-        const statements = migration.up
-            .split(';')
-            .map((s) => s.trim())
-            .filter((s) => s.length > 0);
-        // Wrap the whole migration in a transaction so a mid-statement failure
-        // rolls back to the pre-migration state. The schema_version bump is the
-        // final statement inside the transaction, so an aborted migration won't
-        // leave the DB in a half-applied state with the version already bumped.
-        const applyMigration = db.transaction(() => {
-            for (const stmt of statements) {
-                try {
-                    // For ALTER TABLE ADD COLUMN, check if column already exists first
-                    const addMatch = stmt.match(/ALTER\s+TABLE\s+(\S+)\s+ADD\s+COLUMN\s+(\S+)/i);
-                    if (addMatch) {
-                        const columns = db.pragma(`table_info(${addMatch[1]})`);
-                        if (columns.some((c) => c.name === addMatch[2])) {
-                            logger.debug(`Migration v${migration.version}: column ${addMatch[1]}.${addMatch[2]} already exists, skipping`);
-                            continue;
-                        }
-                    }
-                    // For ALTER TABLE DROP COLUMN, skip if column already gone
-                    const dropMatch = stmt.match(/ALTER\s+TABLE\s+(\S+)\s+DROP\s+COLUMN\s+(\S+)/i);
-                    if (dropMatch) {
-                        const columns = db.pragma(`table_info(${dropMatch[1]})`);
-                        if (!columns.some((c) => c.name === dropMatch[2])) {
-                            logger.debug(`Migration v${migration.version}: column ${dropMatch[1]}.${dropMatch[2]} already absent, skipping`);
-                            continue;
-                        }
-                    }
-                    db.exec(stmt);
-                }
-                catch (err) {
-                    const msg = err instanceof Error ? err.message : String(err);
-                    if (msg.includes('already exists') ||
-                        msg.includes('no such column') ||
-                        msg.includes('no such table') ||
-                        msg.includes('no such index')) {
-                        logger.debug(`Migration v${migration.version}: object already in target state, skipping statement`);
-                        continue;
-                    }
-                    throw err;
-                }
-            }
-            db.prepare('UPDATE schema_version SET version = ?').run(migration.version);
-        });
-        applyMigration();
-    }
-}

package/dist/delegation/manager.d.ts

@@ -1,18 +0,0 @@
-export interface Delegation {
-    id: string;
-    sourceTab: string;
-    targetTab: string;
-    message: string;
-    returnToTab: string | null;
-    status: 'pending' | 'running' | 'completed' | 'failed';
-    result: string | null;
-    depth: number;
-    createdAt: string;
-    completedAt: string | null;
-}
-/** Create a new delegation */
-export declare function createDelegation(sourceTab: string, targetTab: string, message: string, returnToTab?: string): Delegation;
-/** Complete a delegation with a result */
-export declare function completeDelegation(targetTab: string, result: string): Delegation | null;
-/** Get pending delegations for a tab */
-export declare function getPendingDelegations(tabName?: string): Delegation[];

package/dist/delegation/manager.js

@@ -1,89 +0,0 @@
-import { v4 as uuidv4 } from 'uuid';
-import { getDb } from '../db/index.js';
-import { logger } from '../util/logger.js';
-const MAX_DELEGATION_DEPTH = 3;
-const MAX_PENDING_PER_TAB = 5;
-/** Create a new delegation */
-export function createDelegation(sourceTab, targetTab, message, returnToTab) {
-    const db = getDb();
-    // Check depth limit
-    const sourceDepth = getCurrentDepth(sourceTab);
-    if (sourceDepth >= MAX_DELEGATION_DEPTH) {
-        throw new Error(`Delegation depth limit reached (max ${MAX_DELEGATION_DEPTH}). Tab "${sourceTab}" cannot delegate further.`);
-    }
-    // Check pending limit
-    const pending = db
-        .prepare("SELECT COUNT(*) as c FROM delegations WHERE source_tab = ? AND status IN ('pending', 'running')")
-        .get(sourceTab).c;
-    if (pending >= MAX_PENDING_PER_TAB) {
-        throw new Error(`Too many pending delegations for tab "${sourceTab}" (max ${MAX_PENDING_PER_TAB}).`);
-    }
-    const id = uuidv4();
-    const delegation = {
-        id,
-        sourceTab,
-        targetTab,
-        message,
-        returnToTab: returnToTab || sourceTab,
-        status: 'pending',
-        result: null,
-        depth: sourceDepth + 1,
-        createdAt: new Date().toISOString(),
-        completedAt: null,
-    };
-    db.prepare('INSERT INTO delegations (id, source_tab, target_tab, message, return_to_tab, status, depth) VALUES (?, ?, ?, ?, ?, ?, ?)').run(id, sourceTab, targetTab, message, delegation.returnToTab, 'pending', delegation.depth);
-    logger.info(`Delegation created: ${sourceTab} → ${targetTab} (depth ${delegation.depth})`);
-    return delegation;
-}
-/** Complete a delegation with a result */
-export function completeDelegation(targetTab, result) {
-    const db = getDb();
-    // Find the most recent pending/running delegation to this tab
-    const row = db
-        .prepare("SELECT * FROM delegations WHERE target_tab = ? AND status IN ('pending', 'running') ORDER BY created_at DESC LIMIT 1")
-        .get(targetTab);
-    if (!row)
-        return null;
-    db.prepare("UPDATE delegations SET status = 'completed', result = ?, completed_at = datetime('now') WHERE id = ?").run(result.slice(0, 50000), row.id); // Cap result at 50KB
-    logger.info(`Delegation completed: ${row.source_tab} → ${row.target_tab}`);
-    return {
-        id: row.id,
-        sourceTab: row.source_tab,
-        targetTab: row.target_tab,
-        message: row.message,
-        returnToTab: row.return_to_tab,
-        status: 'completed',
-        result,
-        depth: row.depth,
-        createdAt: row.created_at,
-        completedAt: new Date().toISOString(),
-    };
-}
-/** Get pending delegations for a tab */
-export function getPendingDelegations(tabName) {
-    const db = getDb();
-    const query = tabName
-        ? "SELECT * FROM delegations WHERE source_tab = ? AND status IN ('pending', 'running') ORDER BY created_at"
-        : "SELECT * FROM delegations WHERE status IN ('pending', 'running') ORDER BY created_at";
-    const rows = tabName ? db.prepare(query).all(tabName) : db.prepare(query).all();
-    return rows.map((r) => ({
-        id: r.id,
-        sourceTab: r.source_tab,
-        targetTab: r.target_tab,
-        message: r.message,
-        returnToTab: r.return_to_tab,
-        status: r.status,
-        result: r.result,
-        depth: r.depth,
-        createdAt: r.created_at,
-        completedAt: r.completed_at,
-    }));
-}
-/** Get current delegation depth for a tab */
-function getCurrentDepth(tabName) {
-    const db = getDb();
-    const row = db
-        .prepare("SELECT MAX(depth) as d FROM delegations WHERE source_tab = ? AND status IN ('pending', 'running')")
-        .get(tabName);
-    return row.d ?? 0;
-}

package/dist/index.d.ts

@@ -1,2 +0,0 @@
-#!/usr/bin/env node
-export {};

package/dist/knowledge/index.d.ts

@@ -1,2 +0,0 @@
-export type { KnowledgeEntry, KnowledgeScope } from './types.js';
-export { getGlobalKnowledge, addGlobalKnowledge, getProjectKnowledge, addProjectKnowledge, getTabKnowledge, getAllKnowledge, formatKnowledgeForContext, addKnowledge, searchKnowledge, } from './manager.js';

package/dist/knowledge/index.js

@@ -1 +0,0 @@
-export { getGlobalKnowledge, addGlobalKnowledge, getProjectKnowledge, addProjectKnowledge, getTabKnowledge, getAllKnowledge, formatKnowledgeForContext, addKnowledge, searchKnowledge, } from './manager.js';

package/dist/knowledge/manager.d.ts

@@ -1,17 +0,0 @@
-import type { KnowledgeEntry, KnowledgeScope } from './types.js';
-export declare function getGlobalKnowledge(): KnowledgeEntry[];
-export declare function addGlobalKnowledge(content: string, category?: string): void;
-export declare function getProjectKnowledge(projectPath: string): KnowledgeEntry[];
-export declare function addProjectKnowledge(projectPath: string, content: string): void;
-export declare function getTabKnowledge(tabName: string): KnowledgeEntry[];
-export declare function getAllKnowledge(projectPath?: string, tabName?: string): KnowledgeEntry[];
-/** Format knowledge for injection into Claude's context */
-export declare function formatKnowledgeForContext(entries: KnowledgeEntry[]): string;
-/** Add knowledge to the right scope */
-export declare function addKnowledge(content: string, scope: KnowledgeScope, options?: {
-    projectPath?: string;
-    tabName?: string;
-    category?: string;
-}): void;
-/** Search knowledge across all layers */
-export declare function searchKnowledge(query: string, projectPath?: string, tabName?: string): KnowledgeEntry[];

package/dist/knowledge/manager.js

@@ -1,160 +0,0 @@
-import fs from 'node:fs';
-import path from 'node:path';
-import { getDb } from '../db/index.js';
-import { getBeecorkHome } from '../util/paths.js';
-import { logger } from '../util/logger.js';
-const GLOBAL_KNOWLEDGE_DIR = path.join(getBeecorkHome(), 'knowledge');
-const GLOBAL_CATEGORIES = ['people', 'preferences', 'routines', 'general'];
-/** Ensure global knowledge directory exists */
-function ensureGlobalDir() {
-    fs.mkdirSync(GLOBAL_KNOWLEDGE_DIR, { recursive: true, mode: 0o700 });
-}
-const knowledgeCache = new Map();
-/** Read a knowledge file with mtime-based caching, return content or empty string */
-function readKnowledgeCached(filePath) {
-    // Skip the existsSync precheck — fs.statSync throws ENOENT on missing files,
-    // catching that gets us the same fall-through. This halves the syscall count
-    // on every Claude message that triggers knowledge injection.
-    try {
-        const stat = fs.statSync(filePath);
-        const cached = knowledgeCache.get(filePath);
-        if (cached && cached.mtime === stat.mtimeMs)
-            return cached.content;
-        const content = fs.readFileSync(filePath, 'utf-8');
-        knowledgeCache.set(filePath, { content, mtime: stat.mtimeMs });
-        return content;
-    }
-    catch (err) {
-        if (err?.code === 'ENOENT')
-            return '';
-        logger.warn(`Failed to read knowledge file ${filePath}:`, err);
-        return '';
-    }
-}
-/** Append to a knowledge file */
-function appendToFile(filePath, content) {
-    fs.mkdirSync(path.dirname(filePath), { recursive: true, mode: 0o700 });
-    const existing = readKnowledgeCached(filePath);
-    const separator = existing.endsWith('\n') || existing === '' ? '' : '\n';
-    fs.writeFileSync(filePath, existing + separator + content + '\n', { mode: 0o600 });
-    try {
-        fs.chmodSync(filePath, 0o600);
-    }
-    catch {
-        /* not fatal */
-    }
-}
-// ─── Layer 1: Global Knowledge ───
-export function getGlobalKnowledge() {
-    ensureGlobalDir();
-    const entries = [];
-    for (const category of GLOBAL_CATEGORIES) {
-        const filePath = path.join(GLOBAL_KNOWLEDGE_DIR, `${category}.md`);
-        const content = readKnowledgeCached(filePath);
-        if (content.trim()) {
-            entries.push({ content, scope: 'global', source: `${category}.md`, category });
-        }
-    }
-    return entries;
-}
-export function addGlobalKnowledge(content, category = 'general') {
-    ensureGlobalDir();
-    const validCategory = GLOBAL_CATEGORIES.includes(category) ? category : 'general';
-    const filePath = path.join(GLOBAL_KNOWLEDGE_DIR, `${validCategory}.md`);
-    appendToFile(filePath, content);
-    logger.info(`Global knowledge added to ${validCategory}.md`);
-}
-// ─── Layer 2: Project Knowledge ───
-export function getProjectKnowledge(projectPath) {
-    const filePath = path.join(projectPath, '.beecork', 'knowledge.md');
-    const content = readKnowledgeCached(filePath);
-    if (!content.trim())
-        return [];
-    return [{ content, scope: 'project', source: filePath }];
-}
-export function addProjectKnowledge(projectPath, content) {
-    const filePath = path.join(projectPath, '.beecork', 'knowledge.md');
-    appendToFile(filePath, content);
-    logger.info(`Project knowledge added to ${filePath}`);
-}
-// ─── Layer 3: Tab Knowledge (database) ───
-export function getTabKnowledge(tabName) {
-    const db = getDb();
-    const rows = db
-        .prepare('SELECT content FROM memories WHERE tab_name = ? ORDER BY created_at DESC LIMIT 50')
-        .all(tabName);
-    return rows.map((r) => ({ content: r.content, scope: 'tab', source: tabName }));
-}
-// ─── Combined Knowledge ───
-export function getAllKnowledge(projectPath, tabName) {
-    const entries = [];
-    // Layer 1: Global
-    entries.push(...getGlobalKnowledge());
-    // Layer 2: Project (if provided)
-    if (projectPath) {
-        entries.push(...getProjectKnowledge(projectPath));
-    }
-    // Layer 3: Tab (if provided)
-    if (tabName) {
-        entries.push(...getTabKnowledge(tabName));
-    }
-    return entries;
-}
-/** Format knowledge for injection into Claude's context */
-export function formatKnowledgeForContext(entries) {
-    if (entries.length === 0)
-        return '';
-    const sections = [];
-    const global = entries.filter((e) => e.scope === 'global');
-    if (global.length > 0) {
-        sections.push('[Your knowledge (global)]');
-        for (const entry of global) {
-            if (entry.category)
-                sections.push(`[${entry.category}]`);
-            sections.push(entry.content);
-        }
-    }
-    const project = entries.filter((e) => e.scope === 'project');
-    if (project.length > 0) {
-        sections.push('\n[Project knowledge]');
-        for (const entry of project) {
-            sections.push(entry.content);
-        }
-    }
-    const tab = entries.filter((e) => e.scope === 'tab');
-    if (tab.length > 0) {
-        sections.push('\n[Context from memory]');
-        for (const entry of tab) {
-            sections.push(`- ${entry.content}`);
-        }
-    }
-    return sections.join('\n');
-}
-/** Add knowledge to the right scope */
-export function addKnowledge(content, scope, options) {
-    switch (scope) {
-        case 'global':
-            addGlobalKnowledge(content, options?.category);
-            break;
-        case 'project':
-            if (!options?.projectPath)
-                throw new Error('projectPath required for project scope');
-            addProjectKnowledge(options.projectPath, content);
-            break;
-        case 'tab': {
-            // Use existing memory system. Inline INSERT here (rather than the
-            // MemoryStore wrapper) because knowledge → session would invert the
-            // module dep direction; the schema duplication is one column list and
-            // the shape is stable.
-            const db = getDb();
-            db.prepare('INSERT INTO memories (content, tab_name, source) VALUES (?, ?, ?)').run(content, options?.tabName || null, 'tool');
-            break;
-        }
-    }
-}
-/** Search knowledge across all layers */
-export function searchKnowledge(query, projectPath, tabName) {
-    const all = getAllKnowledge(projectPath, tabName);
-    const lower = query.toLowerCase();
-    return all.filter((e) => e.content.toLowerCase().includes(lower));
-}

package/dist/knowledge/types.d.ts

@@ -1,7 +0,0 @@
-export type KnowledgeScope = 'global' | 'project' | 'tab';
-export interface KnowledgeEntry {
-    content: string;
-    scope: KnowledgeScope;
-    source: string;
-    category?: string;
-}