thepopebot 1.1.2 → 1.2.0

package/api/index.js

@@ -1,12 +1,8 @@
-const paths = require('../lib/paths');
-const { render_md } = require('../lib/utils/render-md');
 const { createJob } = require('../lib/tools/create-job');
-const { setWebhook, sendMessage, downloadFile, reactToMessage, startTypingIndicator } = require('../lib/tools/telegram');
-const { isWhisperEnabled, transcribeAudio } = require('../lib/tools/openai');
-const { chat, getApiKey } = require('../lib/claude');
-const { toolDefinitions, toolExecutors } = require('../lib/claude/tools');
-const { getHistory, updateHistory } = require('../lib/claude/conversation');
+const { setWebhook, sendMessage } = require('../lib/tools/telegram');
 const { getJobStatus } = require('../lib/tools/github');
+const { getTelegramAdapter } = require('../lib/channels');
+const { chat, summarizeJob, addToThread } = require('../lib/ai');
 
 // Bot token from env, can be overridden by /telegram/register
 let telegramBotToken = null;
@@ -57,55 +53,6 @@ function extractJobId(branchName) {
   return branchName.slice(4);
 }
 
-/**
- * Summarize a completed job using Claude
- * @param {Object} results - Job results from webhook payload
- * @returns {Promise<string>} The message to send to Telegram
- */
-async function summarizeJob(results) {
-  try {
-    const apiKey = getApiKey();
-
-    // System prompt from JOB_SUMMARY.md (supports {{includes}})
-    const systemPrompt = render_md(paths.jobSummaryMd);
-
-    // User message: structured job results
-    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');
-
-    const response = await fetch('https://api.anthropic.com/v1/messages', {
-      method: 'POST',
-      headers: {
-        'Content-Type': 'application/json',
-        'x-api-key': apiKey,
-        'anthropic-version': '2023-06-01',
-      },
-      body: JSON.stringify({
-        model: process.env.EVENT_HANDLER_MODEL || 'claude-sonnet-4-20250514',
-        max_tokens: 1024,
-        system: systemPrompt,
-        messages: [{ role: 'user', content: userMessage }],
-      }),
-    });
-
-    if (!response.ok) throw new Error(`Claude API error: ${response.status}`);
-
-    const result = await response.json();
-    return (result.content?.[0]?.text || '').trim() || 'Job finished.';
-  } catch (err) {
-    console.error('Failed to summarize job:', err);
-    return 'Job finished.';
-  }
-}
-
 // ─────────────────────────────────────────────────────────────────────────────
 // Route handlers
 // ─────────────────────────────────────────────────────────────────────────────
@@ -142,100 +89,42 @@ async function handleTelegramRegister(request) {
 }
 
 async function handleTelegramWebhook(request) {
-  const { TELEGRAM_WEBHOOK_SECRET, TELEGRAM_CHAT_ID, TELEGRAM_VERIFICATION } = process.env;
   const botToken = getTelegramBotToken();
+  if (!botToken) return Response.json({ ok: true });
 
-  // Validate secret token if configured
-  // Always return 200 to prevent Telegram retry loops on mismatch
-  if (TELEGRAM_WEBHOOK_SECRET) {
-    const headerSecret = request.headers.get('x-telegram-bot-api-secret-token');
-    if (headerSecret !== TELEGRAM_WEBHOOK_SECRET) {
-      return Response.json({ ok: true });
-    }
-  }
-
-  const update = await request.json();
-  const message = update.message || update.edited_message;
+  const adapter = getTelegramAdapter(botToken);
+  const normalized = await adapter.receive(request);
+  if (!normalized) return Response.json({ ok: true });
 
-  if (message && message.chat && botToken) {
-    const chatId = String(message.chat.id);
-
-    let messageText = null;
-
-    if (message.text) {
-      messageText = message.text;
-    }
-
-    // Check for verification code - this works even before TELEGRAM_CHAT_ID is set
-    if (TELEGRAM_VERIFICATION && messageText === TELEGRAM_VERIFICATION) {
-      await sendMessage(botToken, chatId, `Your chat ID:\n<code>${chatId}</code>`);
-      return Response.json({ ok: true });
-    }
-
-    // Security: if no TELEGRAM_CHAT_ID configured, ignore all messages (except verification above)
-    if (!TELEGRAM_CHAT_ID) {
-      return Response.json({ ok: true });
-    }
-
-    // Security: only accept messages from configured chat
-    if (chatId !== TELEGRAM_CHAT_ID) {
-      return Response.json({ ok: true });
-    }
-
-    // Acknowledge receipt with a thumbs up (await so it completes before typing indicator starts)
-    await reactToMessage(botToken, chatId, message.message_id).catch(() => {});
-
-    if (message.voice) {
-      // Handle voice messages
-      if (!isWhisperEnabled()) {
-        await sendMessage(botToken, chatId, 'Voice messages are not supported. Please set OPENAI_API_KEY to enable transcription.');
-        return Response.json({ ok: true });
-      }
-
-      try {
-        const { buffer, filename } = await downloadFile(botToken, message.voice.file_id);
-        messageText = await transcribeAudio(buffer, filename);
-      } catch (err) {
-        console.error('Failed to transcribe voice:', err);
-        await sendMessage(botToken, chatId, 'Sorry, I could not transcribe your voice message.');
-        return Response.json({ ok: true });
-      }
-    }
-
-    if (messageText) {
-      // Process message asynchronously (don't block the response)
-      processMessage(botToken, chatId, messageText).catch(err => {
-        console.error('Failed to process message:', err);
-      });
-    }
-  }
+  // Process message asynchronously (don't block the webhook response)
+  processChannelMessage(adapter, normalized).catch((err) => {
+    console.error('Failed to process message:', err);
+  });
 
   return Response.json({ ok: true });
 }
 
 /**
- * Process a Telegram message with Claude (async, non-blocking)
+ * Process a normalized message through the AI layer with channel UX.
  */
-async function processMessage(botToken, chatId, messageText) {
-  const stopTyping = startTypingIndicator(botToken, chatId);
+async function processChannelMessage(adapter, normalized) {
+  await adapter.acknowledge(normalized.metadata);
+  const stopIndicator = adapter.startProcessingIndicator(normalized.metadata);
+
   try {
-    // Get conversation history and process with Claude
-    const history = getHistory(chatId);
-    const { response, history: newHistory } = await chat(
-      messageText,
-      history,
-      toolDefinitions,
-      toolExecutors
-    );
-    updateHistory(chatId, newHistory);
-
-    // Send response (auto-splits if needed)
-    await sendMessage(botToken, chatId, response);
+    const response = await chat(normalized.threadId, normalized.text, normalized.attachments);
+    await adapter.sendResponse(normalized.threadId, response, normalized.metadata);
   } catch (err) {
-    console.error('Failed to process message with Claude:', err);
-    await sendMessage(botToken, chatId, 'Sorry, I encountered an error processing your message.').catch(() => {});
+    console.error('Failed to process message with AI:', err);
+    await adapter
+      .sendResponse(
+        normalized.threadId,
+        'Sorry, I encountered an error processing your message.',
+        normalized.metadata
+      )
+      .catch(() => {});
   } finally {
-    stopTyping();
+    stopIndicator();
   }
 }
 
@@ -276,10 +165,8 @@ async function handleGithubWebhook(request) {
 
     await sendMessage(botToken, TELEGRAM_CHAT_ID, message);
 
-    // Add the summary to chat memory so Claude has context in future conversations
-    const history = getHistory(TELEGRAM_CHAT_ID);
-    history.push({ role: 'assistant', content: message });
-    updateHistory(TELEGRAM_CHAT_ID, history);
+    // Add the summary to chat memory so the agent has context in future conversations
+    await addToThread(TELEGRAM_CHAT_ID, message);
 
     console.log(`Notified chat ${TELEGRAM_CHAT_ID} about job ${jobId.slice(0, 8)}`);
 

package/bin/dev.sh

@@ -0,0 +1,30 @@
+#!/bin/bash
+set -e
+
+PACKAGE_DIR="$(cd "$(dirname "$0")/.." && pwd)"
+DEV_DIR="${1:-/tmp/thepopebot}"
+ENV_BACKUP="/tmp/env.$(uuidgen)"
+
+HAS_ENV=false
+if [ -f "$DEV_DIR/.env" ]; then
+  mv "$DEV_DIR/.env" "$ENV_BACKUP"
+  HAS_ENV=true
+fi
+
+rm -rf "$DEV_DIR"
+mkdir -p "$DEV_DIR"
+cd "$DEV_DIR"
+
+node "$PACKAGE_DIR/bin/cli.js" init
+
+sed -i '' "s|\"thepopebot\": \".*\"|\"thepopebot\": \"file:$PACKAGE_DIR\"|" package.json
+
+rm -rf node_modules package-lock.json
+npm install --install-links
+
+if [ "$HAS_ENV" = true ]; then
+  mv "$ENV_BACKUP" .env
+  echo "Restored .env from previous build"
+else
+  npm run setup
+fi

package/config/index.js

@@ -22,6 +22,11 @@ function withThepopebot(nextConfig = {}) {
       '@grammyjs/parse-mode',
       'node-cron',
       'uuid',
+      '@langchain/langgraph',
+      '@langchain/anthropic',
+      '@langchain/core',
+      'zod',
+      'better-sqlite3',
     ],
   };
 }

package/lib/ai/agent.js

@@ -0,0 +1,38 @@
+const { createReactAgent } = require('@langchain/langgraph/prebuilt');
+const { createModel } = require('./model');
+const { createJobTool, getJobStatusTool } = require('./tools');
+const { createCheckpointer } = require('./memory');
+const paths = require('../paths');
+const { render_md } = require('../utils/render-md');
+
+let _agent = null;
+
+/**
+ * Get or create the LangGraph agent singleton.
+ * Uses createReactAgent which handles the tool loop automatically.
+ */
+function getAgent() {
+  if (!_agent) {
+    const model = createModel();
+    const tools = [createJobTool, getJobStatusTool];
+    const checkpointer = createCheckpointer();
+    const systemPrompt = render_md(paths.chatbotMd);
+
+    _agent = createReactAgent({
+      llm: model,
+      tools,
+      checkpointSaver: checkpointer,
+      prompt: systemPrompt,
+    });
+  }
+  return _agent;
+}
+
+/**
+ * Reset the agent singleton (e.g., when config changes).
+ */
+function resetAgent() {
+  _agent = null;
+}
+
+module.exports = { getAgent, resetAgent };

package/lib/ai/index.js

@@ -0,0 +1,147 @@
+const { HumanMessage, AIMessage } = require('@langchain/core/messages');
+const { getAgent } = require('./agent');
+const { createModel } = require('./model');
+const paths = require('../paths');
+const { render_md } = require('../utils/render-md');
+
+/**
+ * Process a chat message through the LangGraph agent.
+ *
+ * @param {string} threadId - Conversation thread ID (from channel adapter)
+ * @param {string} message - User's message text
+ * @param {Array} [attachments=[]] - Normalized attachments from adapter
+ * @returns {Promise<string>} AI response text
+ */
+async function chat(threadId, message, attachments = []) {
+  const agent = getAgent();
+
+  // Build content blocks: text + any image attachments as base64 vision
+  const content = [];
+
+  if (message) {
+    content.push({ type: 'text', text: message });
+  }
+
+  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
+  if (typeof lastMessage.content === 'string') {
+    return lastMessage.content;
+  }
+
+  // Extract text from content blocks
+  return lastMessage.content
+    .filter((block) => block.type === 'text')
+    .map((block) => block.text)
+    .join('\n');
+}
+
+/**
+ * Process a chat message with streaming (for channels that support it).
+ *
+ * @param {string} threadId - Conversation thread ID
+ * @param {string} message - User's message text
+ * @returns {AsyncIterableIterator<string>} Stream of text chunks
+ */
+async function* chatStream(threadId, message) {
+  const agent = getAgent();
+
+  const stream = await agent.stream(
+    { messages: [new HumanMessage(message)] },
+    { configurable: { thread_id: threadId }, streamMode: 'messages' }
+  );
+
+  for await (const [message, metadata] of stream) {
+    if (message.content && typeof message.content === 'string') {
+      yield message.content;
+    }
+  }
+}
+
+/**
+ * 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 = createModel({ maxTokens: 1024 });
+    const systemPrompt = render_md(paths.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');
+
+    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');
+
+    return text.trim() || 'Job finished.';
+  } catch (err) {
+    console.error('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 = getAgent();
+    await agent.updateState(
+      { configurable: { thread_id: threadId } },
+      { messages: [new AIMessage(text)] }
+    );
+  } catch (err) {
+    console.error('Failed to add message to thread:', err);
+  }
+}
+
+module.exports = { chat, chatStream, summarizeJob, addToThread };

package/lib/ai/memory.js

@@ -0,0 +1,39 @@
+const path = require('path');
+const fs = require('fs');
+const paths = require('../paths');
+
+/**
+ * Create a LangGraph checkpointer based on environment configuration.
+ *
+ * Config env vars:
+ *   MEMORY_BACKEND — "memory" (default), "sqlite"
+ *   MEMORY_PATH    — SQLite file path (default: "data/memory.sqlite")
+ *
+ * @returns {import('@langchain/langgraph').BaseCheckpointSaver}
+ */
+function createCheckpointer() {
+  const backend = process.env.MEMORY_BACKEND || 'memory';
+
+  switch (backend) {
+    case 'memory': {
+      const { MemorySaver } = require('@langchain/langgraph');
+      return new MemorySaver();
+    }
+    case 'sqlite': {
+      const { SqliteSaver } = require('@langchain/langgraph-checkpoint-sqlite');
+      const dbPath = process.env.MEMORY_PATH || path.join(paths.dataDir, 'memory.sqlite');
+
+      // Ensure the data directory exists
+      const dir = path.dirname(dbPath);
+      if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+      }
+
+      return SqliteSaver.fromConnString(dbPath);
+    }
+    default:
+      throw new Error(`Unknown memory backend: ${backend}`);
+  }
+}
+
+module.exports = { createCheckpointer };

package/lib/ai/model.js

@@ -0,0 +1,44 @@
+const { ChatAnthropic } = require('@langchain/anthropic');
+
+const DEFAULT_MODEL = 'claude-sonnet-4-20250514';
+
+/**
+ * Create a LangChain chat model based on environment configuration.
+ *
+ * Config env vars:
+ *   LLM_PROVIDER    — "anthropic" (default). Future: "openai", "google", etc.
+ *   LLM_MODEL       — Model name override (e.g. "claude-sonnet-4-20250514")
+ *   ANTHROPIC_API_KEY — Required for anthropic provider
+ *
+ * @param {object} [options]
+ * @param {number} [options.maxTokens=4096] - Max tokens for the response
+ * @returns {import('@langchain/core/language_models/chat_models').BaseChatModel}
+ */
+function createModel(options = {}) {
+  const provider = process.env.LLM_PROVIDER || 'anthropic';
+  const modelName = process.env.LLM_MODEL || DEFAULT_MODEL;
+  const maxTokens = options.maxTokens || 4096;
+
+  switch (provider) {
+    case 'anthropic': {
+      const apiKey = process.env.ANTHROPIC_API_KEY;
+      if (!apiKey) {
+        throw new Error('ANTHROPIC_API_KEY environment variable is required');
+      }
+      return new ChatAnthropic({
+        modelName,
+        maxTokens,
+        anthropicApiKey: apiKey,
+      });
+    }
+    // Future providers:
+    // case 'openai': {
+    //   const { ChatOpenAI } = require('@langchain/openai');
+    //   return new ChatOpenAI({ modelName, maxTokens });
+    // }
+    default:
+      throw new Error(`Unknown LLM provider: ${provider}`);
+  }
+}
+
+module.exports = { createModel };

package/lib/ai/tools.js

@@ -0,0 +1,49 @@
+const { tool } = require('@langchain/core/tools');
+const { z } = require('zod');
+const { createJob } = require('../tools/create-job');
+const { getJobStatus } = require('../tools/github');
+
+const createJobTool = tool(
+  async ({ job_description }) => {
+    const result = await createJob(job_description);
+    return JSON.stringify({
+      success: true,
+      job_id: result.job_id,
+      branch: result.branch,
+    });
+  },
+  {
+    name: 'create_job',
+    description:
+      'Create an autonomous job for thepopebot to execute. Use this tool liberally - if the user asks for ANY task to be done, create a job. Jobs can handle code changes, file updates, research tasks, web scraping, data analysis, or anything requiring autonomous work. When the user explicitly asks for a job, ALWAYS use this tool. Returns the job ID and branch name.',
+    schema: z.object({
+      job_description: z
+        .string()
+        .describe(
+          'Detailed job description including context and requirements. Be specific about what needs to be done.'
+        ),
+    }),
+  }
+);
+
+const getJobStatusTool = tool(
+  async ({ job_id }) => {
+    const result = await getJobStatus(job_id);
+    return JSON.stringify(result);
+  },
+  {
+    name: 'get_job_status',
+    description:
+      'Check status of running jobs. Returns list of active workflow runs with timing and current step. Use when user asks about job progress, running jobs, or job status.',
+    schema: z.object({
+      job_id: z
+        .string()
+        .optional()
+        .describe(
+          'Optional: specific job ID to check. If omitted, returns all running jobs.'
+        ),
+    }),
+  }
+);
+
+module.exports = { createJobTool, getJobStatusTool };

package/lib/channels/base.js

@@ -0,0 +1,56 @@
+/**
+ * Base channel adapter interface.
+ * Every chat channel (Telegram, Slack, web, etc.) implements this contract.
+ */
+class ChannelAdapter {
+  /**
+   * Handle an incoming webhook request from this channel.
+   * Returns normalized message data or null if no action needed.
+   *
+   * @param {Request} request - Incoming HTTP request
+   * @returns {Promise<{ threadId: string, text: string, attachments: Array, metadata: object } | null>}
+   *
+   * Attachments array (may be empty) — only non-text content that the LLM needs to see:
+   *   { category: "image", mimeType: "image/png", data: Buffer }  — send to LLM as vision
+   *   { category: "document", mimeType: "application/pdf", data: Buffer } — future: extract/attach
+   *
+   * The adapter downloads authenticated files and normalizes them.
+   * Voice/audio messages are fully resolved by the adapter — transcribed to text
+   * and included in the `text` field. They are NOT passed as attachments.
+   */
+  async receive(request) {
+    throw new Error('Not implemented');
+  }
+
+  /**
+   * Called when message is received — adapter shows acknowledgment.
+   * Telegram: thumbs up reaction. Slack: emoji reaction. Web: no-op.
+   */
+  async acknowledge(metadata) {}
+
+  /**
+   * Called while AI is processing — adapter shows activity.
+   * Telegram: typing indicator. Slack: typing indicator. Web: no-op (streaming handles this).
+   * Returns a stop function.
+   */
+  startProcessingIndicator(metadata) {
+    return () => {};
+  }
+
+  /**
+   * Send a complete (non-streaming) response back to the channel.
+   */
+  async sendResponse(threadId, text, metadata) {
+    throw new Error('Not implemented');
+  }
+
+  /**
+   * Whether this channel supports real streaming (e.g., web chat via Vercel AI SDK).
+   * If true, the AI layer provides a stream instead of a complete response.
+   */
+  get supportsStreaming() {
+    return false;
+  }
+}
+
+module.exports = { ChannelAdapter };

package/lib/channels/index.js

@@ -0,0 +1,17 @@
+const { TelegramAdapter } = require('./telegram');
+
+let _telegramAdapter = null;
+
+/**
+ * Get the Telegram channel adapter (lazy singleton).
+ * @param {string} botToken - Telegram bot token
+ * @returns {TelegramAdapter}
+ */
+function getTelegramAdapter(botToken) {
+  if (!_telegramAdapter || _telegramAdapter.botToken !== botToken) {
+    _telegramAdapter = new TelegramAdapter(botToken);
+  }
+  return _telegramAdapter;
+}
+
+module.exports = { getTelegramAdapter };

package/lib/channels/telegram.js

@@ -0,0 +1,146 @@
+const { ChannelAdapter } = require('./base');
+const {
+  sendMessage,
+  downloadFile,
+  reactToMessage,
+  startTypingIndicator,
+} = require('../tools/telegram');
+const { isWhisperEnabled, transcribeAudio } = require('../tools/openai');
+
+class TelegramAdapter extends ChannelAdapter {
+  constructor(botToken) {
+    super();
+    this.botToken = botToken;
+  }
+
+  /**
+   * Parse a Telegram webhook update into normalized message data.
+   * Handles: text, voice/audio (transcribed), photos, documents.
+   * Returns null if the update should be ignored.
+   */
+  async receive(request) {
+    const { TELEGRAM_WEBHOOK_SECRET, TELEGRAM_CHAT_ID, TELEGRAM_VERIFICATION } = process.env;
+
+    // Validate secret token if configured
+    if (TELEGRAM_WEBHOOK_SECRET) {
+      const headerSecret = request.headers.get('x-telegram-bot-api-secret-token');
+      if (headerSecret !== TELEGRAM_WEBHOOK_SECRET) {
+        return null;
+      }
+    }
+
+    const update = await request.json();
+    const message = update.message || update.edited_message;
+
+    if (!message || !message.chat || !this.botToken) return null;
+
+    const chatId = String(message.chat.id);
+    let text = message.text || null;
+    const attachments = [];
+
+    // Check for verification code — works even before TELEGRAM_CHAT_ID is set
+    if (TELEGRAM_VERIFICATION && text === TELEGRAM_VERIFICATION) {
+      await sendMessage(this.botToken, chatId, `Your chat ID:\n<code>${chatId}</code>`);
+      return null;
+    }
+
+    // Security: if no TELEGRAM_CHAT_ID configured, ignore all messages
+    if (!TELEGRAM_CHAT_ID) return null;
+
+    // Security: only accept messages from configured chat
+    if (chatId !== TELEGRAM_CHAT_ID) return null;
+
+    // Voice messages → transcribe to text
+    if (message.voice) {
+      if (!isWhisperEnabled()) {
+        await sendMessage(
+          this.botToken,
+          chatId,
+          'Voice messages are not supported. Please set OPENAI_API_KEY to enable transcription.'
+        );
+        return null;
+      }
+      try {
+        const { buffer, filename } = await downloadFile(this.botToken, message.voice.file_id);
+        text = await transcribeAudio(buffer, filename);
+      } catch (err) {
+        console.error('Failed to transcribe voice:', err);
+        await sendMessage(this.botToken, chatId, 'Sorry, I could not transcribe your voice message.');
+        return null;
+      }
+    }
+
+    // Audio messages → transcribe to text
+    if (message.audio && !text) {
+      if (!isWhisperEnabled()) {
+        await sendMessage(
+          this.botToken,
+          chatId,
+          'Audio messages are not supported. Please set OPENAI_API_KEY to enable transcription.'
+        );
+        return null;
+      }
+      try {
+        const { buffer, filename } = await downloadFile(this.botToken, message.audio.file_id);
+        text = await transcribeAudio(buffer, filename);
+      } catch (err) {
+        console.error('Failed to transcribe audio:', err);
+        await sendMessage(this.botToken, chatId, 'Sorry, I could not transcribe your audio message.');
+        return null;
+      }
+    }
+
+    // Photo → download largest size, add as image attachment
+    if (message.photo && message.photo.length > 0) {
+      try {
+        const largest = message.photo[message.photo.length - 1];
+        const { buffer } = await downloadFile(this.botToken, largest.file_id);
+        attachments.push({ category: 'image', mimeType: 'image/jpeg', data: buffer });
+        // Use caption as text if no text yet
+        if (!text && message.caption) text = message.caption;
+      } catch (err) {
+        console.error('Failed to download photo:', err);
+      }
+    }
+
+    // Document → download, add as document attachment
+    if (message.document) {
+      try {
+        const { buffer, filename } = await downloadFile(this.botToken, message.document.file_id);
+        const mimeType = message.document.mime_type || 'application/octet-stream';
+        attachments.push({ category: 'document', mimeType, data: buffer });
+        if (!text && message.caption) text = message.caption;
+      } catch (err) {
+        console.error('Failed to download document:', err);
+      }
+    }
+
+    // Nothing actionable
+    if (!text && attachments.length === 0) return null;
+
+    return {
+      threadId: chatId,
+      text: text || '',
+      attachments,
+      metadata: { messageId: message.message_id, chatId },
+    };
+  }
+
+  async acknowledge(metadata) {
+    await reactToMessage(this.botToken, metadata.chatId, metadata.messageId).catch(() => {});
+  }
+
+  startProcessingIndicator(metadata) {
+    return startTypingIndicator(this.botToken, metadata.chatId);
+  }
+
+  async sendResponse(threadId, text, metadata) {
+    await sendMessage(this.botToken, threadId, text);
+  }
+
+  get supportsStreaming() {
+    return false;
+  }
+}
+
+module.exports = { TelegramAdapter };

package/lib/paths.js

@@ -25,6 +25,9 @@ module.exports = {
   // Logs
   logsDir: path.join(PROJECT_ROOT, 'logs'),
 
+  // Data (SQLite memory, etc.)
+  dataDir: path.join(PROJECT_ROOT, 'data'),
+
   // .env
   envFile: path.join(PROJECT_ROOT, '.env'),
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "thepopebot",
-  "version": "1.1.2",
+  "version": "1.2.0",
   "description": "Create autonomous AI agents with a two-layer architecture: Next.js Event Handler + Docker Agent.",
   "bin": {
     "thepopebot": "./bin/cli.js"
@@ -20,6 +20,7 @@
     "templates/"
   ],
   "scripts": {
+    "dev": "bash bin/dev.sh",
     "postinstall": "node bin/postinstall.js",
     "test": "echo \"No tests yet\" && exit 0"
   },
@@ -36,14 +37,20 @@
   "license": "MIT",
   "dependencies": {
     "@grammyjs/parse-mode": "^2.2.0",
+    "@langchain/anthropic": "^1.3.17",
+    "@langchain/core": "^1.1.24",
+    "@langchain/langgraph": "^1.1.4",
+    "@langchain/langgraph-checkpoint-sqlite": "^1.0.1",
+    "better-sqlite3": "^12.6.2",
+    "chalk": "^5.3.0",
     "dotenv": "^16.3.1",
     "grammy": "^1.39.3",
-    "node-cron": "^3.0.3",
-    "uuid": "^9.0.0",
-    "chalk": "^5.3.0",
     "inquirer": "^9.2.12",
+    "node-cron": "^3.0.3",
     "open": "^10.0.0",
-    "ora": "^8.0.1"
+    "ora": "^8.0.1",
+    "uuid": "^9.0.0",
+    "zod": "^4.3.6"
   },
   "peerDependencies": {
     "next": ">=15.0.0",

package/lib/claude/conversation.js

@@ -1,76 +0,0 @@
-/**
- * In-memory conversation history management per Telegram chat.
- * - Keyed by chat_id
- * - 30-minute TTL per conversation
- * - Max 20 messages per conversation
- */
-
-const MAX_MESSAGES = 20;
-const TTL_MS = 30 * 60 * 1000; // 30 minutes
-const CLEANUP_INTERVAL_MS = 5 * 60 * 1000; // 5 minutes
-
-// Map<chatId, { messages: Array, lastAccess: number }>
-const conversations = new Map();
-
-/**
- * Get conversation history for a chat
- * @param {string} chatId - Telegram chat ID
- * @returns {Array} - Message history array
- */
-function getHistory(chatId) {
-  const entry = conversations.get(chatId);
-  if (!entry) return [];
-
-  // Check if expired
-  if (Date.now() - entry.lastAccess > TTL_MS) {
-    conversations.delete(chatId);
-    return [];
-  }
-
-  entry.lastAccess = Date.now();
-  return entry.messages;
-}
-
-/**
- * Update conversation history for a chat
- * @param {string} chatId - Telegram chat ID
- * @param {Array} messages - New message history
- */
-function updateHistory(chatId, messages) {
-  // Trim to max messages (keep most recent)
-  const trimmed = messages.slice(-MAX_MESSAGES);
-
-  conversations.set(chatId, {
-    messages: trimmed,
-    lastAccess: Date.now(),
-  });
-}
-
-/**
- * Clear conversation history for a chat
- * @param {string} chatId - Telegram chat ID
- */
-function clearHistory(chatId) {
-  conversations.delete(chatId);
-}
-
-/**
- * Clean up expired conversations
- */
-function cleanupExpired() {
-  const now = Date.now();
-  for (const [chatId, entry] of conversations) {
-    if (now - entry.lastAccess > TTL_MS) {
-      conversations.delete(chatId);
-    }
-  }
-}
-
-// Start cleanup interval
-setInterval(cleanupExpired, CLEANUP_INTERVAL_MS);
-
-module.exports = {
-  getHistory,
-  updateHistory,
-  clearHistory,
-};

package/lib/claude/index.js

@@ -1,142 +0,0 @@
-const paths = require('../paths');
-const { render_md } = require('../utils/render-md');
-
-const DEFAULT_MODEL = 'claude-sonnet-4-20250514';
-
-// Web search tool definition (Anthropic built-in)
-const WEB_SEARCH_TOOL = {
-  type: 'web_search_20250305',
-  name: 'web_search',
-  max_uses: 5,
-};
-
-/**
- * Get Anthropic API key from environment
- * @returns {string} API key
- */
-function getApiKey() {
-  if (process.env.ANTHROPIC_API_KEY) {
-    return process.env.ANTHROPIC_API_KEY;
-  }
-  throw new Error('ANTHROPIC_API_KEY environment variable is required');
-}
-
-/**
- * Call Claude API
- * @param {Array} messages - Conversation messages
- * @param {Array} tools - Tool definitions
- * @returns {Promise<Object>} API response
- */
-async function callClaude(messages, tools) {
-  const apiKey = getApiKey();
-  const model = process.env.EVENT_HANDLER_MODEL || DEFAULT_MODEL;
-  const systemPrompt = render_md(paths.chatbotMd);
-
-  // Combine user tools with web search
-  const allTools = [WEB_SEARCH_TOOL, ...tools];
-
-  const response = await fetch('https://api.anthropic.com/v1/messages', {
-    method: 'POST',
-    headers: {
-      'Content-Type': 'application/json',
-      'x-api-key': apiKey,
-      'anthropic-version': '2023-06-01',
-      'anthropic-beta': 'web-search-2025-03-05',
-    },
-    body: JSON.stringify({
-      model,
-      max_tokens: 4096,
-      system: systemPrompt,
-      messages,
-      tools: allTools,
-    }),
-  });
-
-  if (!response.ok) {
-    const error = await response.text();
-    throw new Error(`Claude API error: ${response.status} ${error}`);
-  }
-
-  return response.json();
-}
-
-/**
- * Process a conversation turn with Claude, handling tool calls
- * @param {string} userMessage - User's message
- * @param {Array} history - Conversation history
- * @param {Array} toolDefinitions - Available tools
- * @param {Object} toolExecutors - Tool executor functions
- * @returns {Promise<{response: string, history: Array}>}
- */
-async function chat(userMessage, history, toolDefinitions, toolExecutors) {
-  // Add user message to history
-  const messages = [...history, { role: 'user', content: userMessage }];
-
-  let response = await callClaude(messages, toolDefinitions);
-  let assistantContent = response.content;
-
-  // Add assistant response to history
-  messages.push({ role: 'assistant', content: assistantContent });
-
-  // Handle tool use loop
-  while (response.stop_reason === 'tool_use') {
-    const toolResults = [];
-
-    for (const block of assistantContent) {
-      if (block.type === 'tool_use') {
-        // Skip web_search - it's a server-side tool executed by Anthropic
-        if (block.name === 'web_search') {
-          continue;
-        }
-
-        const executor = toolExecutors[block.name];
-        let result;
-
-        if (executor) {
-          try {
-            result = await executor(block.input);
-          } catch (err) {
-            result = { error: err.message };
-          }
-        } else {
-          result = { error: `Unknown tool: ${block.name}` };
-        }
-
-        toolResults.push({
-          type: 'tool_result',
-          tool_use_id: block.id,
-          content: JSON.stringify(result),
-        });
-      }
-    }
-
-    // If no client-side tools to execute, we're done
-    if (toolResults.length === 0) {
-      break;
-    }
-
-    // Add tool results to messages
-    messages.push({ role: 'user', content: toolResults });
-
-    // Get next response from Claude
-    response = await callClaude(messages, toolDefinitions);
-    assistantContent = response.content;
-
-    // Add new assistant response to history
-    messages.push({ role: 'assistant', content: assistantContent });
-  }
-
-  // Extract text response
-  const textBlocks = assistantContent.filter((block) => block.type === 'text');
-  const responseText = textBlocks.map((block) => block.text).join('\n');
-
-  return {
-    response: responseText,
-    history: messages,
-  };
-}
-
-module.exports = {
-  chat,
-  getApiKey,
-};

package/lib/claude/tools.js

@@ -1,54 +0,0 @@
-const { createJob } = require('../tools/create-job');
-const { getJobStatus } = require('../tools/github');
-
-const toolDefinitions = [
-  {
-    name: 'create_job',
-    description:
-      'Create an autonomous job for thepopebot to execute. Use this tool liberally - if the user asks for ANY task to be done, create a job. Jobs can handle code changes, file updates, research tasks, web scraping, data analysis, or anything requiring autonomous work. When the user explicitly asks for a job, ALWAYS use this tool. Returns the job ID and branch name.',
-    input_schema: {
-      type: 'object',
-      properties: {
-        job_description: {
-          type: 'string',
-          description:
-            'Detailed job description including context and requirements. Be specific about what needs to be done.',
-        },
-      },
-      required: ['job_description'],
-    },
-  },
-  {
-    name: 'get_job_status',
-    description:
-      'Check status of running jobs. Returns list of active workflow runs with timing and current step. Use when user asks about job progress, running jobs, or job status.',
-    input_schema: {
-      type: 'object',
-      properties: {
-        job_id: {
-          type: 'string',
-          description:
-            'Optional: specific job ID to check. If omitted, returns all running jobs.',
-        },
-      },
-      required: [],
-    },
-  },
-];
-
-const toolExecutors = {
-  create_job: async (input) => {
-    const result = await createJob(input.job_description);
-    return {
-      success: true,
-      job_id: result.job_id,
-      branch: result.branch,
-    };
-  },
-  get_job_status: async (input) => {
-    const result = await getJobStatus(input.job_id);
-    return result;
-  },
-};
-
-module.exports = { toolDefinitions, toolExecutors };