@harbinger-ai/harbinger 0.1.0

package/lib/ai/autonomous-engine.js

@@ -0,0 +1,261 @@
+/**
+ * AutonomousEngine — Background thinking loop for agents.
+ *
+ * Every agent runs this engine to continuously analyze context, identify
+ * improvements, calculate efficiency, and propose automations. Thoughts are
+ * stored in-memory and logged (no external API needed).
+ *
+ * Adapted from Harbinger's agents/shared/autonomous-engine.js.
+ * Key change: stores thoughts locally instead of POSTing to swarm API.
+ *
+ * COST_BENEFIT = (TIME_SAVED * FREQUENCY) / (IMPL_COST + RUNNING_COST)
+ * Only proposals with cost_benefit > 1.0 get surfaced.
+ */
+
+import { discoverAgents } from '../agents.js';
+
+const MAX_THOUGHTS = 200; // Rolling buffer size
+
+export class AutonomousEngine {
+  constructor(opts = {}) {
+    this.agentId = opts.agentId || 'unknown';
+    this.agentName = opts.agentName || 'AGENT';
+    this.agentType = opts.agentType || 'general';
+    this.interval = opts.interval || 60000; // 60-second thinking cycle
+    this._timer = null;
+    this._running = false;
+    this._cycleCount = 0;
+    this._lastContext = null;
+    this._thoughts = []; // in-memory thought storage
+  }
+
+  start() {
+    if (this._running) return;
+    this._running = true;
+    console.log(`[${this.agentName}] Autonomous engine started (${this.interval / 1000}s cycle)`);
+
+    // Run first cycle immediately, then on interval
+    this._think();
+    this._timer = setInterval(() => this._think(), this.interval);
+  }
+
+  stop() {
+    this._running = false;
+    if (this._timer) {
+      clearInterval(this._timer);
+      this._timer = null;
+    }
+    console.log(`[${this.agentName}] Autonomous engine stopped after ${this._cycleCount} cycles`);
+  }
+
+  async _think() {
+    this._cycleCount++;
+    try {
+      // 1. Gather context — what agents are available locally?
+      const context = this._gatherContext();
+      this._lastContext = context;
+
+      // 2. Identify enhancements — scan 5 dimensions
+      const enhancements = this._identifyEnhancements(context);
+
+      // 3. For each enhancement, calculate efficiency and classify
+      for (const enhancement of enhancements) {
+        const efficiency = this._calculateEfficiency(enhancement);
+
+        // Only store if cost-benefit ratio is positive
+        if (efficiency.cost_benefit >= 1.0) {
+          enhancement.efficiency = efficiency;
+          enhancement.efficiency.automation_type = this._classifyAutomation(enhancement);
+          this._storeThought(enhancement);
+        }
+      }
+    } catch (err) {
+      // Silent fail — don't crash the agent over thinking errors
+      if (this._cycleCount <= 3) {
+        console.error(`[${this.agentName}] Think cycle error:`, err.message);
+      }
+    }
+  }
+
+  /**
+   * Gather local context — discover agents and their statuses.
+   * No HTTP calls — everything is in-process.
+   */
+  _gatherContext() {
+    try {
+      const agents = discoverAgents();
+      return {
+        agents,
+        agentCount: agents.length,
+        self: agents.find(a => a.id === this.agentId) || null,
+        thoughtCount: this._thoughts.length,
+        cycleCount: this._cycleCount,
+      };
+    } catch {
+      return { agents: [], agentCount: 0, self: null, thoughtCount: 0, cycleCount: this._cycleCount };
+    }
+  }
+
+  // Scan 5 dimensions for potential enhancements
+  _identifyEnhancements(context) {
+    const enhancements = [];
+
+    // Dimension 1: Performance — detect high thought volume
+    if (context.thoughtCount > 50) {
+      enhancements.push({
+        type: 'enhancement',
+        category: 'performance',
+        title: `${this.agentName} generating high thought volume`,
+        content: `Engine has ${context.thoughtCount} thoughts. Consider batch processing or reducing scan frequency.`,
+        priority: 2,
+      });
+    }
+
+    // Dimension 2: Accuracy — check cycle health
+    if (context.cycleCount > 100 && context.thoughtCount === 0) {
+      enhancements.push({
+        type: 'observation',
+        category: 'accuracy',
+        title: 'No actionable thoughts after many cycles',
+        content: `${context.cycleCount} cycles completed with no thoughts. Consider adjusting thresholds.`,
+        priority: 3,
+      });
+    }
+
+    // Dimension 3: Cost — monitor cycle count
+    if (context.cycleCount > 1000) {
+      enhancements.push({
+        type: 'alert',
+        category: 'cost',
+        title: 'High cycle count — consider throttling',
+        content: `Engine has run ${context.cycleCount} cycles. Consider increasing interval to reduce resource usage.`,
+        priority: 4,
+      });
+    }
+
+    // Dimension 4: Automation — detect idle potential
+    if (context.agentCount > 0) {
+      enhancements.push({
+        type: 'proposal',
+        category: 'automation',
+        title: `${context.agentCount} agent profiles available`,
+        content: `Agent profiles detected: ${context.agents.map(a => a.codename || a.id).join(', ')}. Could schedule proactive scans.`,
+        priority: 2,
+      });
+    }
+
+    // Dimension 5: Collaboration — multi-agent coordination
+    if (context.agentCount > 3) {
+      enhancements.push({
+        type: 'proposal',
+        category: 'collaboration',
+        title: 'Multiple agents available — suggest coordinated workflow',
+        content: `${context.agentCount} agent profiles loaded. Consider launching coordinated assessments.`,
+        priority: 3,
+      });
+    }
+
+    return enhancements;
+  }
+
+  // Calculate cost-benefit ratio for an enhancement
+  _calculateEfficiency(enhancement) {
+    const baseTimeSaved = { performance: 2, accuracy: 1, cost: 3, automation: 4, collaboration: 2 };
+    const baseFrequency = { performance: 7, accuracy: 3, cost: 1, automation: 14, collaboration: 2 };
+    const baseCost = { performance: 4, accuracy: 2, cost: 1, automation: 8, collaboration: 6 };
+
+    const cat = enhancement.category || 'automation';
+    const timeSaved = (baseTimeSaved[cat] || 1) * (enhancement.priority / 3);
+    const frequency = baseFrequency[cat] || 1;
+    const implCost = baseCost[cat] || 4;
+    const runningCost = implCost * 0.1;
+
+    const costBenefit = (timeSaved * frequency) / (implCost + runningCost);
+
+    return {
+      time_saved: Math.round(timeSaved * 100) / 100,
+      frequency,
+      implementation_cost: implCost,
+      running_cost: Math.round(runningCost * 100) / 100,
+      cost_benefit: Math.round(costBenefit * 100) / 100,
+      automation_type: 'script',
+    };
+  }
+
+  _classifyAutomation(enhancement) {
+    const cat = enhancement.category;
+    if (cat === 'automation') return 'script';
+    if (cat === 'performance') return 'code_change';
+    if (cat === 'collaboration') return 'workflow';
+    if (cat === 'accuracy') return 'skill';
+    return 'script';
+  }
+
+  /**
+   * Store thought in the local rolling buffer.
+   */
+  _storeThought(thought) {
+    const entry = {
+      timestamp: new Date().toISOString(),
+      agent_id: this.agentId,
+      agent_name: this.agentName,
+      type: thought.type || 'observation',
+      category: thought.category || '',
+      title: thought.title || 'Untitled thought',
+      content: thought.content || '',
+      priority: thought.priority || 3,
+      efficiency: thought.efficiency || null,
+    };
+
+    this._thoughts.push(entry);
+
+    // Rolling buffer — trim oldest
+    if (this._thoughts.length > MAX_THOUGHTS) {
+      this._thoughts = this._thoughts.slice(-MAX_THOUGHTS);
+    }
+  }
+
+  /** Get all stored thoughts. */
+  getThoughts() {
+    return [...this._thoughts];
+  }
+
+  /** Get the last gathered context. */
+  getLastContext() {
+    return this._lastContext;
+  }
+
+  /** Get engine status. */
+  getStatus() {
+    return {
+      running: this._running,
+      cycles: this._cycleCount,
+      agent: this.agentName,
+      interval: this.interval,
+      thoughtCount: this._thoughts.length,
+    };
+  }
+}
+
+let _engine = null;
+
+/** Get the AutonomousEngine singleton. */
+export function getAutonomousEngine() {
+  return _engine;
+}
+
+/** Start the autonomous engine with the given options. */
+export function startAutonomousEngine(opts = {}) {
+  if (_engine) return _engine;
+  _engine = new AutonomousEngine(opts);
+  _engine.start();
+  return _engine;
+}
+
+/** Stop the autonomous engine. */
+export function stopAutonomousEngine() {
+  if (_engine) {
+    _engine.stop();
+    _engine = null;
+  }
+}

package/lib/ai/index.js

@@ -0,0 +1,359 @@
+import { HumanMessage, AIMessage } from '@langchain/core/messages';
+import { z } from 'zod';
+import { getAgent, getAgentForProfile } from './agent.js';
+import { createModel } from './model.js';
+import { jobSummaryMd } from '../paths.js';
+import { render_md } from '../utils/render-md.js';
+import { getChatById, createChat, saveMessage, updateChatTitle } from '../db/chats.js';
+import { discoverAgents } from '../agents.js';
+
+/**
+ * Detect @AGENT_NAME mentions at the start of a message.
+ * Returns { agentId, cleanMessage } or null if no mention found.
+ * Matches @codename or @id (case-insensitive) against discovered agent profiles.
+ */
+let _agentMap = null;
+function detectAgentMention(message) {
+  if (!message) return null;
+  const match = message.match(/^@(\w[\w-]*)\s+/i);
+  if (!match) return null;
+
+  const mention = match[1].toLowerCase();
+
+  // Lazy-load agent map
+  if (!_agentMap) {
+    try {
+      const agents = discoverAgents();
+      _agentMap = new Map();
+      for (const a of agents) {
+        if (a.codename) _agentMap.set(a.codename.toLowerCase(), a.id);
+        if (a.id) _agentMap.set(a.id.toLowerCase(), a.id);
+        if (a.name) _agentMap.set(a.name.toLowerCase(), a.id);
+      }
+    } catch {
+      _agentMap = new Map();
+    }
+  }
+
+  const agentId = _agentMap.get(mention);
+  if (!agentId) return null;
+  return { agentId, cleanMessage: message.slice(match[0].length) };
+}
+
+/**
+ * Ensure a chat exists in the DB and save a message.
+ * Centralized so every channel gets persistence automatically.
+ *
+ * @param {string} threadId - Chat/thread ID
+ * @param {string} role - 'user' or 'assistant'
+ * @param {string} text - Message text
+ * @param {object} [options] - { userId, chatTitle }
+ */
+function persistMessage(threadId, role, text, options = {}) {
+  try {
+    if (!getChatById(threadId)) {
+      createChat(options.userId || 'unknown', options.chatTitle || 'New Chat', threadId);
+    }
+    saveMessage(threadId, role, text);
+  } catch (err) {
+    // DB persistence is best-effort — don't break chat if DB fails
+    console.error('Failed to persist message:', err);
+  }
+}
+
+/**
+ * Process a chat message through the LangGraph agent.
+ * Saves user and assistant messages to the DB automatically.
+ *
+ * @param {string} threadId - Conversation thread ID (from channel adapter)
+ * @param {string} message - User's message text
+ * @param {Array} [attachments=[]] - Normalized attachments from adapter
+ * @param {object} [options] - { userId, chatTitle } for DB persistence
+ * @returns {Promise<string>} AI response text
+ */
+async function chat(threadId, message, attachments = [], options = {}) {
+  // Detect @AGENT_NAME mention or use explicit agentId option
+  let effectiveMessage = message;
+  let agentId = options.agentId || null;
+  if (!agentId && message) {
+    const mention = detectAgentMention(message);
+    if (mention) {
+      agentId = mention.agentId;
+      effectiveMessage = mention.cleanMessage;
+    }
+  }
+  const agent = agentId ? await getAgentForProfile(agentId) : await getAgent();
+
+  // Save user message to DB (save original message with @mention)
+  persistMessage(threadId, 'user', message || '[attachment]', options);
+
+  // Build content blocks: text + any image attachments as base64 vision
+  // Use effectiveMessage (with @mention stripped) for the LLM
+  const content = [];
+
+  if (effectiveMessage) {
+    content.push({ type: 'text', text: effectiveMessage });
+  }
+
+  for (const att of attachments) {
+    if (att.category === 'image') {
+      content.push({
+        type: 'image_url',
+        image_url: {
+          url: `data:${att.mimeType};base64,${att.data.toString('base64')}`,
+        },
+      });
+    }
+    // Documents: future handling
+  }
+
+  // If only text and no attachments, simplify to a string
+  const messageContent = content.length === 1 && content[0].type === 'text'
+    ? content[0].text
+    : content;
+
+  const result = await agent.invoke(
+    { messages: [new HumanMessage({ content: messageContent })] },
+    { configurable: { thread_id: threadId } }
+  );
+
+  const lastMessage = result.messages[result.messages.length - 1];
+
+  // LangChain message content can be a string or an array of content blocks
+  let response;
+  if (typeof lastMessage.content === 'string') {
+    response = lastMessage.content;
+  } else {
+    response = lastMessage.content
+      .filter((block) => block.type === 'text')
+      .map((block) => block.text)
+      .join('\n');
+  }
+
+  // Save assistant response to DB
+  persistMessage(threadId, 'assistant', response, options);
+
+  // Auto-generate title for new chats
+  if (options.userId && message) {
+    autoTitle(threadId, message).catch(() => {});
+  }
+
+  return response;
+}
+
+/**
+ * Process a chat message with streaming (for channels that support it).
+ * Saves user and assistant messages to the DB automatically.
+ *
+ * @param {string} threadId - Conversation thread ID
+ * @param {string} message - User's message text
+ * @param {Array} [attachments=[]] - Image/PDF attachments: { category, mimeType, dataUrl }
+ * @param {object} [options] - { userId, chatTitle, skipUserPersist } for DB persistence
+ * @returns {AsyncIterableIterator<string>} Stream of text chunks
+ */
+async function* chatStream(threadId, message, attachments = [], options = {}) {
+  // Detect @AGENT_NAME mention or use explicit agentId option
+  let effectiveMessage = message;
+  let agentId = options.agentId || null;
+  if (!agentId && message) {
+    const mention = detectAgentMention(message);
+    if (mention) {
+      agentId = mention.agentId;
+      effectiveMessage = mention.cleanMessage;
+    }
+  }
+  const agent = agentId ? await getAgentForProfile(agentId) : await getAgent();
+
+  // Save user message to DB (skip on regeneration — message already exists)
+  if (!options.skipUserPersist) {
+    persistMessage(threadId, 'user', message || '[attachment]', options);
+  }
+
+  // Build content blocks: text + any image/PDF attachments as vision
+  // Use effectiveMessage (with @mention stripped) for the LLM
+  const content = [];
+
+  if (effectiveMessage) {
+    content.push({ type: 'text', text: effectiveMessage });
+  }
+
+  for (const att of attachments) {
+    if (att.category === 'image') {
+      // Support both dataUrl (web) and Buffer (Telegram) formats
+      const url = att.dataUrl
+        ? att.dataUrl
+        : `data:${att.mimeType};base64,${att.data.toString('base64')}`;
+      content.push({
+        type: 'image_url',
+        image_url: { url },
+      });
+    }
+  }
+
+  // If only text and no attachments, simplify to a string
+  const messageContent = content.length === 1 && content[0].type === 'text'
+    ? content[0].text
+    : content;
+
+  try {
+    const stream = await agent.stream(
+      { messages: [new HumanMessage({ content: messageContent })] },
+      { configurable: { thread_id: threadId }, streamMode: 'messages' }
+    );
+
+    let fullText = '';
+
+    for await (const event of stream) {
+      // streamMode: 'messages' yields [message, metadata] tuples
+      const msg = Array.isArray(event) ? event[0] : event;
+      const msgType = msg._getType?.();
+
+      if (msgType === 'ai') {
+        // Tool calls — AIMessage.tool_calls is an array of { id, name, args }
+        if (msg.tool_calls?.length > 0) {
+          for (const tc of msg.tool_calls) {
+            yield {
+              type: 'tool-call',
+              toolCallId: tc.id,
+              toolName: tc.name,
+              args: tc.args,
+            };
+          }
+        }
+
+        // Text content (wrapped in structured object)
+        let text = '';
+        if (typeof msg.content === 'string') {
+          text = msg.content;
+        } else if (Array.isArray(msg.content)) {
+          text = msg.content
+            .filter((b) => b.type === 'text' && b.text)
+            .map((b) => b.text)
+            .join('');
+        }
+
+        if (text) {
+          fullText += text;
+          yield { type: 'text', text };
+        }
+      } else if (msgType === 'tool') {
+        // Tool result — ToolMessage has tool_call_id and content
+        yield {
+          type: 'tool-result',
+          toolCallId: msg.tool_call_id,
+          result: msg.content,
+        };
+      }
+      // Skip other message types (human, system)
+    }
+
+    // Save assistant response to DB
+    if (fullText) {
+      persistMessage(threadId, 'assistant', fullText, options);
+    }
+
+    // Auto-generate title for new chats
+    if (options.userId && message) {
+      autoTitle(threadId, message).catch(() => {});
+    }
+  } catch (err) {
+    console.error('[chatStream] error:', err);
+    throw err;
+  }
+}
+
+/**
+ * Auto-generate a chat title from the first user message (fire-and-forget).
+ * Uses structured output to avoid thinking-token leaks with extended-thinking models.
+ */
+async function autoTitle(threadId, firstMessage) {
+  try {
+    const chat = getChatById(threadId);
+    if (!chat || chat.title !== 'New Chat') return;
+
+    const model = await createModel({ maxTokens: 250 });
+    const response = await model.withStructuredOutput(z.object({ title: z.string() })).invoke([
+      ['system', 'Generate a descriptive (8-12 word) title for this chat based on the user\'s first message.'],
+      ['human', firstMessage],
+    ]);
+    if (response.title.trim()) {
+      updateChatTitle(threadId, response.title.trim());
+    }
+  } catch (err) {
+    console.error('[autoTitle] Failed to generate title:', err.message);
+  }
+}
+
+/**
+ * One-shot summarization with a different system prompt and no memory.
+ * Used for job completion summaries sent via GitHub webhook.
+ *
+ * @param {object} results - Job results from webhook payload
+ * @returns {Promise<string>} Summary text
+ */
+async function summarizeJob(results) {
+  try {
+    const model = await createModel({ maxTokens: 1024 });
+    const systemPrompt = render_md(jobSummaryMd);
+
+    if (!systemPrompt) {
+      console.error(`[summarizeJob] Empty system prompt — JOB_SUMMARY.md not found or empty at: ${jobSummaryMd}`);
+    }
+
+    const userMessage = [
+      results.job ? `## Task\n${results.job}` : '',
+      results.commit_message ? `## Commit Message\n${results.commit_message}` : '',
+      results.changed_files?.length ? `## Changed Files\n${results.changed_files.join('\n')}` : '',
+      results.status ? `## Status\n${results.status}` : '',
+      results.merge_result ? `## Merge Result\n${results.merge_result}` : '',
+      results.pr_url ? `## PR URL\n${results.pr_url}` : '',
+      results.run_url ? `## Run URL\n${results.run_url}` : '',
+      results.log ? `## Agent Log\n${results.log}` : '',
+    ]
+      .filter(Boolean)
+      .join('\n\n');
+
+    console.log(`[summarizeJob] System prompt: ${systemPrompt.length} chars, user message: ${userMessage.length} chars`);
+
+    const response = await model.invoke([
+      ['system', systemPrompt],
+      ['human', userMessage],
+    ]);
+
+    const text =
+      typeof response.content === 'string'
+        ? response.content
+        : response.content
+            .filter((block) => block.type === 'text')
+            .map((block) => block.text)
+            .join('\n');
+
+    console.log(`[summarizeJob] Result: ${text.length} chars — ${text.slice(0, 200)}`);
+
+    return text.trim() || 'Job finished.';
+  } catch (err) {
+    console.error('[summarizeJob] Failed to summarize job:', err);
+    return 'Job finished.';
+  }
+}
+
+/**
+ * Inject a message into a thread's memory so the agent has context
+ * for future conversations (e.g., job completion summaries).
+ *
+ * @param {string} threadId - Conversation thread ID
+ * @param {string} text - Message text to inject as an assistant message
+ */
+async function addToThread(threadId, text) {
+  try {
+    const agent = await getAgent();
+    await agent.updateState(
+      { configurable: { thread_id: threadId } },
+      { messages: [new AIMessage(text)] }
+    );
+  } catch (err) {
+    console.error('Failed to add message to thread:', err);
+  }
+}
+
+export { chat, chatStream, summarizeJob, addToThread, persistMessage };