bernard-agent 0.5.2 → 0.6.0

package/dist/repl.js

@@ -51,9 +51,19 @@ const update_js_1 = require("./update.js");
 const store_js_1 = require("./cron/store.js");
 const client_js_1 = require("./cron/client.js");
 const history_js_1 = require("./history.js");
+const ai_1 = require("ai");
+const index_js_1 = require("./providers/index.js");
 const context_js_1 = require("./context.js");
 const domains_js_1 = require("./domains.js");
 const routines_js_1 = require("./routines.js");
+const specialists_js_1 = require("./specialists.js");
+const specialist_candidates_js_1 = require("./specialist-candidates.js");
+const specialist_detector_js_1 = require("./specialist-detector.js");
+const task_js_1 = require("./tools/task.js");
+const index_js_2 = require("./tools/index.js");
+const output_js_2 = require("./output.js");
+const memory_context_js_1 = require("./memory-context.js");
+const logger_js_1 = require("./logger.js");
 /**
  * Launch the interactive REPL, wiring up readline, MCP servers, memory stores, and the agent loop.
  * @param config - Resolved runtime configuration (provider, model, tokens, etc.).
@@ -63,7 +73,8 @@ const routines_js_1 = require("./routines.js");
 async function startRepl(config, alertContext, resume) {
     const SLASH_COMMANDS = [
         { command: '/help', description: 'Show this help' },
-        { command: '/clear', description: 'Clear conversation history and scratch notes' },
+        { command: '/clear', description: 'Clear conversation (--save/-s to summarize first)' },
+        { command: '/compact', description: 'Compress conversation history in-place' },
         { command: '/memory', description: 'List persistent memories' },
         { command: '/scratch', description: 'List session scratch notes' },
         { command: '/mcp', description: 'List MCP servers and tools' },
@@ -73,13 +84,23 @@ async function startRepl(config, alertContext, resume) {
         { command: '/provider', description: 'Switch LLM provider' },
         { command: '/model', description: 'Switch model for current provider' },
         { command: '/theme', description: 'Switch color theme' },
-        { command: '/options', description: 'View and set options (max-tokens, shell-timeout)' },
+        {
+            command: '/options',
+            description: 'View and set options (max-tokens, shell-timeout, token-window)',
+        },
         { command: '/update', description: 'Check for and install updates' },
+        { command: '/task', description: 'Run an isolated task (no history, structured output)' },
         { command: '/routines', description: 'List saved routines' },
         { command: '/create-routine', description: 'Create a routine with guided AI assistance' },
+        { command: '/specialists', description: 'List specialist agents' },
+        { command: '/create-specialist', description: 'Create a specialist with guided AI assistance' },
+        { command: '/candidates', description: 'Review specialist suggestions' },
+        { command: '/critic', description: 'Toggle critic mode for response verification' },
         { command: '/exit', description: 'Quit Bernard' },
     ];
     const routineStore = new routines_js_1.RoutineStore();
+    const specialistStore = new specialists_js_1.SpecialistStore();
+    const candidateStore = new specialist_candidates_js_1.CandidateStore();
     let cachedAllCommands = null;
     let cachedAllCommandsAt = 0;
     const COMMAND_CACHE_TTL = 5_000; // 5 seconds
@@ -113,7 +134,8 @@ async function startRepl(config, alertContext, resume) {
     let isPasting = false;
     function getPromptStr() {
         const { ansi } = (0, theme_js_1.getTheme)();
-        return `${ansi.prompt}bernard>${ansi.reset} `;
+        const criticLabel = config.criticMode ? `${ansi.warning}[CRITIC]${ansi.reset} ` : '';
+        return `${criticLabel}${ansi.prompt}bernard>${ansi.reset} `;
     }
     if (process.stdin.isTTY) {
         process.stdout.write('\x1b[?2004h'); // enable bracket paste mode
@@ -149,10 +171,14 @@ async function startRepl(config, alertContext, resume) {
     }
     let processing = false;
     let interrupted = false;
+    let taskAbortController = null;
     process.stdin.on('keypress', (_str, key) => {
         if (!key)
             return;
         if (key.name === 'escape' && processing) {
+            if (taskAbortController) {
+                taskAbortController.abort();
+            }
             agent.abort();
             interrupted = true;
             return;
@@ -274,7 +300,15 @@ async function startRepl(config, alertContext, resume) {
             (0, output_js_1.printInfo)('No previous conversation found — starting fresh.');
         }
     }
-    const agent = new agent_js_1.Agent(config, toolOptions, memoryStore, mcpTools, mcpServerNames, alertContext, initialHistory, ragStore, routineStore);
+    // Surface pending specialist candidates at session start
+    candidateStore.pruneOld();
+    const pendingCandidates = candidateStore.listPending();
+    if (pendingCandidates.length > 0) {
+        (0, output_js_1.printInfo)(`  ${pendingCandidates.length} specialist suggestion(s) pending. Use /candidates to review.`);
+        const candidateContext = `## Specialist Suggestions\n\nBernard detected patterns in previous sessions that might benefit from saved specialists. Mention these when relevant.\n\n${pendingCandidates.map((c) => `- "${c.name}" (${c.draftId}): ${c.description}`).join('\n')}`;
+        alertContext = alertContext ? alertContext + '\n\n' + candidateContext : candidateContext;
+    }
+    const agent = new agent_js_1.Agent(config, toolOptions, memoryStore, mcpTools, mcpServerNames, alertContext, initialHistory, ragStore, routineStore, specialistStore);
     let cleanedUp = false;
     const cleanup = async () => {
         if (cleanedUp)
@@ -341,7 +375,80 @@ async function startRepl(config, alertContext, resume) {
                 void prompt();
                 return;
             }
-            if (trimmed === '/clear') {
+            if (trimmed === '/clear' || trimmed.startsWith('/clear ')) {
+                const clearArgs = trimmed.slice('/clear'.length).trim();
+                const shouldSave = clearArgs === '--save' || clearArgs === '-s';
+                if (clearArgs && !shouldSave) {
+                    (0, output_js_1.printError)('Usage: /clear [--save|-s]');
+                    void prompt();
+                    return;
+                }
+                if (shouldSave) {
+                    const history = agent.getHistory();
+                    if (history.length < 2) {
+                        (0, output_js_1.printInfo)('Not enough conversation to summarize.');
+                    }
+                    else {
+                        processing = true;
+                        (0, output_js_1.startSpinner)('Summarizing conversation...');
+                        try {
+                            const serialized = (0, context_js_1.serializeMessages)(history);
+                            const [summaryResult, domainFacts, candidateResult] = await Promise.all([
+                                (0, ai_1.generateText)({
+                                    model: (0, index_js_1.getModel)(config.provider, config.model),
+                                    maxTokens: 2048,
+                                    system: context_js_1.SUMMARIZATION_PROMPT,
+                                    messages: [
+                                        { role: 'user', content: `Summarize this conversation:\n\n${serialized}` },
+                                    ],
+                                }),
+                                (0, context_js_1.extractDomainFacts)(serialized, config),
+                                (0, specialist_detector_js_1.detectSpecialistCandidate)(serialized, config, specialistStore.getSummaries(), candidateStore.listPending()).catch(() => null),
+                            ]);
+                            const summary = summaryResult.text?.trim();
+                            if (summary) {
+                                const key = `session-summary-${new Date().toISOString().replace(/[:.]/g, '-')}`;
+                                memoryStore.writeMemory(key, summary);
+                                (0, output_js_1.printInfo)(`Summary saved to memory: ${key}`);
+                            }
+                            if (ragStore && domainFacts.length > 0) {
+                                const totalFacts = domainFacts.reduce((sum, df) => sum + df.facts.length, 0);
+                                const results = await Promise.allSettled(domainFacts.map((df) => ragStore.addFacts(df.facts, 'clear-save', df.domain)));
+                                let storedFacts = 0;
+                                results.forEach((result, i) => {
+                                    if (result.status === 'fulfilled') {
+                                        storedFacts += domainFacts[i].facts.length;
+                                    }
+                                    else {
+                                        (0, logger_js_1.debugLog)('repl:clear-save:rag', `Failed to store facts for domain ${domainFacts[i].domain}: ${result.reason instanceof Error ? result.reason.message : String(result.reason)}`);
+                                    }
+                                });
+                                if (storedFacts > 0) {
+                                    (0, output_js_1.printInfo)(storedFacts === totalFacts
+                                        ? `Extracted ${storedFacts} facts to RAG memory.`
+                                        : `Extracted ${storedFacts}/${totalFacts} facts to RAG memory.`);
+                                }
+                            }
+                            if (candidateResult) {
+                                try {
+                                    candidateStore.create(candidateResult, 'clear-save');
+                                    (0, output_js_1.printInfo)(`Specialist suggestion detected: "${candidateResult.name}". Use /candidates to review.`);
+                                }
+                                catch {
+                                    // Silent — candidate storage failure is non-critical
+                                }
+                            }
+                        }
+                        catch (err) {
+                            const message = err instanceof Error ? err.message : String(err);
+                            (0, output_js_1.printError)(`Failed to summarize: ${message}. Clearing anyway.`);
+                        }
+                        finally {
+                            processing = false;
+                            (0, output_js_1.stopSpinner)();
+                        }
+                    }
+                }
                 agent.clearHistory();
                 historyStore.clear();
                 console.clear();
@@ -350,6 +457,38 @@ async function startRepl(config, alertContext, resume) {
                 void prompt();
                 return;
             }
+            if (trimmed === '/compact') {
+                const history = agent.getHistory();
+                if (history.length < 2) {
+                    (0, output_js_1.printInfo)('Not enough conversation to compact.');
+                    void prompt();
+                    return;
+                }
+                processing = true;
+                (0, output_js_1.startSpinner)('Compacting conversation...');
+                try {
+                    const result = await agent.compactHistory();
+                    (0, output_js_1.stopSpinner)();
+                    if (!result.compacted) {
+                        (0, output_js_1.printInfo)('Nothing to compact — conversation is already short enough.');
+                    }
+                    else {
+                        const pct = Math.round(((result.tokensBefore - result.tokensAfter) / result.tokensBefore) * 100);
+                        (0, output_js_1.printInfo)(`Compacted: ~${(0, output_js_1.formatTokenCount)(result.tokensBefore)} → ~${(0, output_js_1.formatTokenCount)(result.tokensAfter)} tokens (${pct}% reduction)`);
+                    }
+                    historyStore.save(agent.getHistory());
+                }
+                catch (err) {
+                    const message = err instanceof Error ? err.message : String(err);
+                    (0, output_js_1.printError)(`Compaction failed: ${message}`);
+                }
+                finally {
+                    processing = false;
+                    (0, output_js_1.stopSpinner)();
+                }
+                void prompt();
+                return;
+            }
             if (trimmed === '/memory') {
                 const keys = memoryStore.listMemory();
                 if (keys.length === 0) {
@@ -520,6 +659,7 @@ async function startRepl(config, alertContext, resume) {
                             model: config.model,
                             maxTokens: config.maxTokens,
                             shellTimeout: config.shellTimeout,
+                            tokenWindow: config.tokenWindow,
                             theme: config.theme,
                         });
                         (0, output_js_1.printInfo)(`  Switched to ${config.provider} (${config.model})`);
@@ -554,6 +694,7 @@ async function startRepl(config, alertContext, resume) {
                             model: config.model,
                             maxTokens: config.maxTokens,
                             shellTimeout: config.shellTimeout,
+                            tokenWindow: config.tokenWindow,
                             theme: config.theme,
                         });
                         (0, output_js_1.printInfo)(`  Switched to ${config.model}`);
@@ -598,6 +739,7 @@ async function startRepl(config, alertContext, resume) {
                             model: config.model,
                             maxTokens: config.maxTokens,
                             shellTimeout: config.shellTimeout,
+                            tokenWindow: config.tokenWindow,
                             theme: chosen,
                         });
                         (0, output_js_1.printInfo)(`  Switched to ${theme_js_1.THEMES[chosen].name} theme.`);
@@ -628,16 +770,23 @@ async function startRepl(config, alertContext, resume) {
                         const [name, opt] = entries[num - 1];
                         rl.question(`  New value for ${name} (Enter to cancel): `, (valAnswer) => {
                             const val = parseInt(valAnswer.trim(), 10);
-                            if (val > 0) {
+                            const minVal = opt.default === 0 ? 0 : 1;
+                            if (!isNaN(val) && val >= minVal) {
                                 (0, config_js_1.saveOption)(name, val);
                                 config[opt.configKey] = val;
                                 (0, output_js_1.printInfo)(`  ${name} set to ${val}`);
+                                if (name === 'token-window') {
+                                    const modelWindow = (0, context_js_1.getContextWindow)(config.model);
+                                    if (val > modelWindow) {
+                                        (0, output_js_1.printInfo)(`  Warning: ${val} exceeds ${config.model}'s context window (${modelWindow})`);
+                                    }
+                                }
                             }
                             else if (valAnswer.trim() === '') {
                                 (0, output_js_1.printInfo)('  Cancelled.');
                             }
                             else {
-                                (0, output_js_1.printError)('  Invalid value. Must be a positive integer.');
+                                (0, output_js_1.printError)(`  Invalid value. Must be ${minVal === 0 ? 'a non-negative integer' : 'a positive integer'}.`);
                             }
                             console.log();
                             void prompt();
@@ -697,6 +846,73 @@ Remember: routine content should be written as clear instructions that Bernard c
                         totalCompletionTokens: 0,
                         latestPromptTokens: 0,
                         model: config.model,
+                        contextWindowOverride: config.tokenWindow || undefined,
+                    };
+                    agent.setSpinnerStats(spinnerStats);
+                    (0, output_js_1.startSpinner)(() => (0, output_js_1.buildSpinnerMessage)(spinnerStats));
+                    await agent.processInput(message);
+                    historyStore.save(agent.getHistory());
+                }
+                catch (err) {
+                    if (!interrupted) {
+                        const message = err instanceof Error ? err.message : String(err);
+                        (0, output_js_1.printError)(message);
+                    }
+                }
+                finally {
+                    processing = false;
+                    (0, output_js_1.stopSpinner)();
+                }
+                if (interrupted) {
+                    (0, output_js_1.printInfo)('Interrupted.');
+                    interrupted = false;
+                }
+                console.log();
+                void prompt();
+                return;
+            }
+            if (trimmed === '/specialists') {
+                const specialists = specialistStore.list();
+                if (specialists.length === 0) {
+                    (0, output_js_1.printInfo)('No specialist agents defined yet. Ask me to create one or use /create-specialist.');
+                }
+                else {
+                    (0, output_js_1.printInfo)(`\n  Specialists (${specialists.length}):`);
+                    for (const s of specialists) {
+                        (0, output_js_1.printInfo)(`    ${s.id} — ${s.name}: ${s.description}`);
+                    }
+                    console.log();
+                }
+                void prompt();
+                return;
+            }
+            if (trimmed === '/create-specialist') {
+                const message = `The user wants to create a new specialist agent interactively. Guide them through the process:
+
+1. Ask what domain or recurring task pattern the specialist covers (e.g., email triage, code review, data analysis)
+2. Ask about behavioral preferences — how should the specialist approach work? What tone, priorities, output formats, or decision rules should it follow?
+3. Ask about specific guidelines — are there things it should always or never do?
+4. Once you have enough information, draft the specialist by creating:
+   - **id**: kebab-case slug (e.g., "email-triage")
+   - **name**: display name (e.g., "Email Triage Specialist")
+   - **description**: one-line summary
+   - **systemPrompt**: the specialist's persona and behavioral instructions (this is the core — write it like a focused system prompt)
+   - **guidelines**: short behavioral rules as a list of strings
+5. Present the draft to the user for review
+6. Make any requested changes
+7. Use the specialist tool to save it once the user approves
+
+Remember: the systemPrompt should read like a persona definition — who this specialist is, what they care about, how they work. Guidelines are individual rules that can be added/removed independently.`;
+                processing = true;
+                interrupted = false;
+                try {
+                    const spinnerStats = {
+                        startTime: Date.now(),
+                        totalPromptTokens: 0,
+                        totalCompletionTokens: 0,
+                        latestPromptTokens: 0,
+                        model: config.model,
+                        contextWindowOverride: config.tokenWindow || undefined,
                     };
                     agent.setSpinnerStats(spinnerStats);
                     (0, output_js_1.startSpinner)(() => (0, output_js_1.buildSpinnerMessage)(spinnerStats));
@@ -721,6 +937,153 @@ Remember: routine content should be written as clear instructions that Bernard c
                 void prompt();
                 return;
             }
+            if (trimmed === '/candidates') {
+                const pending = candidateStore.listPending();
+                if (pending.length === 0) {
+                    (0, output_js_1.printInfo)('No pending specialist suggestions.');
+                }
+                else {
+                    const t = (0, theme_js_1.getTheme)();
+                    (0, output_js_1.printInfo)(`\n  Specialist Suggestions (${pending.length}):\n`);
+                    for (const c of pending) {
+                        const pct = Math.round(c.confidence * 100);
+                        const date = new Date(c.detectedAt).toLocaleDateString();
+                        console.log(t.text(`    ${c.name}`) + t.muted(` (${c.draftId})`));
+                        console.log(t.muted(`      ${c.description}`));
+                        console.log(t.muted(`      Confidence: ${pct}% | Detected: ${date}`));
+                        console.log(t.muted(`      Reasoning: ${c.reasoning}`));
+                        console.log();
+                        candidateStore.acknowledge(c.id);
+                    }
+                    (0, output_js_1.printInfo)('  To accept or reject, tell Bernard conversationally (e.g., "accept the code-review candidate").');
+                    (0, output_js_1.printInfo)('  The agent can create the specialist via the specialist tool, then update candidate status.\n');
+                    // Inject candidate context so the agent knows about them for the rest of the session
+                    const candidateContext = `## Specialist Suggestions\n\nBernard detected patterns in previous sessions that might benefit from saved specialists. Mention these when relevant.\n\n${pending.map((c) => `- "${c.name}" (${c.draftId}): ${c.description}`).join('\n')}`;
+                    agent.setAlertContext(candidateContext);
+                }
+                void prompt();
+                return;
+            }
+            if (trimmed === '/critic' || trimmed.startsWith('/critic ')) {
+                const arg = trimmed.slice('/critic'.length).trim().toLowerCase();
+                if (arg === 'on') {
+                    config.criticMode = true;
+                    (0, config_js_1.savePreferences)({
+                        provider: config.provider,
+                        model: config.model,
+                        maxTokens: config.maxTokens,
+                        shellTimeout: config.shellTimeout,
+                        tokenWindow: config.tokenWindow,
+                        theme: config.theme,
+                        criticMode: true,
+                    });
+                    (0, output_js_1.printInfo)('[CRITIC:ON] Responses will be planned and verified.');
+                }
+                else if (arg === 'off') {
+                    config.criticMode = false;
+                    (0, config_js_1.savePreferences)({
+                        provider: config.provider,
+                        model: config.model,
+                        maxTokens: config.maxTokens,
+                        shellTimeout: config.shellTimeout,
+                        tokenWindow: config.tokenWindow,
+                        theme: config.theme,
+                        criticMode: false,
+                    });
+                    (0, output_js_1.printInfo)('[CRITIC:OFF] Critic mode disabled.');
+                }
+                else {
+                    (0, output_js_1.printInfo)(`Critic mode: ${config.criticMode ? 'ON' : 'OFF'}. Usage: /critic on|off`);
+                }
+                void prompt();
+                return;
+            }
+            if (trimmed === '/task' || trimmed.startsWith('/task ')) {
+                const taskDescription = trimmed.slice('/task'.length).trim();
+                if (!taskDescription) {
+                    (0, output_js_1.printError)('Usage: /task <description>');
+                    (0, output_js_1.printInfo)('  Example: /task List all .ts files in the src directory');
+                    void prompt();
+                    return;
+                }
+                processing = true;
+                interrupted = false;
+                taskAbortController = new AbortController();
+                (0, output_js_2.printTaskStart)(taskDescription);
+                (0, output_js_1.startSpinner)('Running task...');
+                try {
+                    const baseTools = (0, index_js_2.createTools)(toolOptions, memoryStore, mcpTools);
+                    // Optional RAG search for context
+                    let ragResults;
+                    if (ragStore) {
+                        try {
+                            ragResults = await ragStore.search(taskDescription);
+                            if (ragResults.length > 0) {
+                                (0, logger_js_1.debugLog)('repl:task:rag', {
+                                    query: taskDescription.slice(0, 100),
+                                    results: ragResults.length,
+                                });
+                            }
+                        }
+                        catch (err) {
+                            (0, logger_js_1.debugLog)('repl:task:rag:error', err instanceof Error ? err.message : String(err));
+                        }
+                    }
+                    const systemPrompt = task_js_1.TASK_SYSTEM_PROMPT +
+                        (0, memory_context_js_1.buildMemoryContext)({ memoryStore, ragResults, includeScratch: false });
+                    const result = await (0, ai_1.generateText)({
+                        model: (0, index_js_1.getModel)(config.provider, config.model),
+                        tools: baseTools,
+                        maxSteps: 5,
+                        maxTokens: config.maxTokens,
+                        system: systemPrompt,
+                        messages: [{ role: 'user', content: `Task: ${taskDescription}` }],
+                        abortSignal: taskAbortController.signal,
+                        onStepFinish: ({ text, toolCalls, toolResults }) => {
+                            for (const tc of toolCalls) {
+                                (0, output_js_2.printToolCall)(tc.toolName, tc.args);
+                            }
+                            for (const tr of toolResults) {
+                                (0, output_js_2.printToolResult)(tr.toolName, tr.result);
+                            }
+                            if (text) {
+                                (0, output_js_2.printAssistantText)(text);
+                            }
+                        },
+                    });
+                    (0, output_js_1.stopSpinner)();
+                    const taskResult = (0, task_js_1.wrapTaskResult)(result.text);
+                    (0, output_js_2.printTaskEnd)(JSON.stringify(taskResult));
+                    // Print the full output for the user
+                    const t = (0, theme_js_1.getTheme)();
+                    if (taskResult.details) {
+                        console.log(t.text(`\n${taskResult.output}\n${taskResult.details}`));
+                    }
+                    else {
+                        console.log(t.text(`\n${taskResult.output}`));
+                    }
+                }
+                catch (err) {
+                    (0, output_js_1.stopSpinner)();
+                    if (!interrupted) {
+                        const message = err instanceof Error ? err.message : String(err);
+                        (0, output_js_2.printTaskEnd)(JSON.stringify({ status: 'error', output: message }));
+                        (0, output_js_1.printError)(message);
+                    }
+                }
+                finally {
+                    processing = false;
+                    taskAbortController = null;
+                    (0, output_js_1.stopSpinner)();
+                }
+                if (interrupted) {
+                    (0, output_js_1.printInfo)('Interrupted.');
+                    interrupted = false;
+                }
+                console.log();
+                void prompt();
+                return;
+            }
             // Dynamic routine invocation: /{routine-id} [args...]
             {
                 const parts = trimmed.slice(1).split(/\s+/);
@@ -743,6 +1106,7 @@ Remember: routine content should be written as clear instructions that Bernard c
                             totalCompletionTokens: 0,
                             latestPromptTokens: 0,
                             model: config.model,
+                            contextWindowOverride: config.tokenWindow || undefined,
                         };
                         agent.setSpinnerStats(spinnerStats);
                         (0, output_js_1.startSpinner)(() => (0, output_js_1.buildSpinnerMessage)(spinnerStats));
@@ -778,6 +1142,7 @@ Remember: routine content should be written as clear instructions that Bernard c
                 totalCompletionTokens: 0,
                 latestPromptTokens: 0,
                 model: config.model,
+                contextWindowOverride: config.tokenWindow || undefined,
             };
             agent.setSpinnerStats(spinnerStats);
             (0, output_js_1.startSpinner)(() => (0, output_js_1.buildSpinnerMessage)(spinnerStats));