thepopebot 1.2.75 → 1.2.76-beta.10

package/api/index.js

@@ -3,7 +3,7 @@ import { createAgentJob } from '../lib/tools/create-agent-job.js';
 import { setWebhook } from '../lib/tools/telegram.js';
 import { getAgentJobStatus, fetchAgentJobLog } from '../lib/tools/github.js';
 import { getTelegramAdapter } from '../lib/channels/index.js';
-import { chat, summarizeAgentJob } from '../lib/ai/index.js';
+import { chat, chatStream, summarizeAgentJob } from '../lib/ai/index.js';
 import { createNotification } from '../lib/db/notifications.js';
 import { loadTriggers } from '../lib/triggers.js';
 import { verifyApiKey } from '../lib/db/api-keys.js';
@@ -211,19 +211,33 @@ async function handleTelegramWebhook(request) {
 /**
  * Process a normalized message through the AI layer with channel UX.
  * Message persistence is handled centrally by the AI layer.
+ *
+ * Uses chatStream() for progressive tool-call rendering when the adapter
+ * supports it (Telegram: sends each tool call as a message, reacts on completion).
+ * Falls back to chat() for adapters without streamChatResponse.
  */
 async function processChannelMessage(adapter, normalized) {
   await adapter.acknowledge(normalized.metadata);
   const stopIndicator = adapter.startProcessingIndicator(normalized.metadata);
 
   try {
-    const response = await chat(
-      normalized.threadId,
-      normalized.text,
-      normalized.attachments,
-      { userId: 'telegram', chatTitle: 'Telegram' }
-    );
-    await adapter.sendResponse(normalized.threadId, response, normalized.metadata);
+    if (adapter.streamChatResponse) {
+      const chunks = chatStream(
+        normalized.threadId,
+        normalized.text,
+        normalized.attachments,
+        { userId: 'telegram', chatTitle: 'Telegram' }
+      );
+      await adapter.streamChatResponse(normalized.metadata.chatId, chunks);
+    } else {
+      const response = await chat(
+        normalized.threadId,
+        normalized.text,
+        normalized.attachments,
+        { userId: 'telegram', chatTitle: 'Telegram' }
+      );
+      await adapter.sendResponse(normalized.threadId, response, normalized.metadata);
+    }
   } catch (err) {
     console.error('Failed to process message with AI:', err);
     await adapter

package/bin/cli.js

@@ -305,6 +305,31 @@ async function init() {
     console.log('  Created .claude/skills → ../skills/active');
   }
 
+  // Create .codex/skills → ../skills/active symlink
+  const codexSkillsLink = path.join(cwd, '.codex', 'skills');
+  if (!fs.existsSync(codexSkillsLink)) {
+    fs.mkdirSync(path.dirname(codexSkillsLink), { recursive: true });
+    createDirLink('../skills/active', codexSkillsLink);
+    console.log('  Created .codex/skills → ../skills/active');
+  }
+
+  // Create .gemini/skills → ../skills/active symlink
+  const geminiSkillsLink = path.join(cwd, '.gemini', 'skills');
+  if (!fs.existsSync(geminiSkillsLink)) {
+    fs.mkdirSync(path.dirname(geminiSkillsLink), { recursive: true });
+    createDirLink('../skills/active', geminiSkillsLink);
+    console.log('  Created .gemini/skills → ../skills/active');
+  }
+
+  // Create .kimi/skills → ../skills/active symlink
+  const kimiSkillsLink = path.join(cwd, '.kimi', 'skills');
+  if (!fs.existsSync(kimiSkillsLink)) {
+    fs.mkdirSync(path.dirname(kimiSkillsLink), { recursive: true });
+    createDirLink('../skills/active', kimiSkillsLink);
+    console.log('  Created .kimi/skills → ../skills/active');
+  }
+
+
   // Report backed-up files
   if (backedUp.length > 0) {
     console.log(`\n  Backed up ${backedUp.length} file(s) to ${path.relative(cwd, backupDir)}/`);
@@ -420,7 +445,7 @@ function reset(filePath) {
       console.log(`  ${destPath(file)}`);
     }
     console.log('\nUsage: thepopebot reset <file>');
-    console.log('Example: thepopebot reset agent-job/SOUL.md\n');
+    console.log('Example: thepopebot reset agent-job/SYSTEM.md\n');
     return;
   }
 
@@ -502,7 +527,7 @@ function diff(filePath) {
       console.log('  All files match package templates.');
     }
     console.log('\nUsage: thepopebot diff <file>');
-    console.log('Example: thepopebot diff agent-job/SOUL.md\n');
+    console.log('Example: thepopebot diff agent-job/SYSTEM.md\n');
     return;
   }
 

package/bin/sync.js

@@ -271,10 +271,13 @@ function buildDockerImage(projectPath) {
   const version = pkg.version;
   const imageTag = `stephengpope/thepopebot:event-handler-${version}`;
 
-  // Copy web/ to project for Docker build context
+  // Copy web/ and docker/ to project for Docker build context
   const webSrc = path.join(PACKAGE_DIR, 'web');
   const webDest = path.join(projectPath, 'web');
+  const dockerSrc = path.join(PACKAGE_DIR, 'docker');
+  const dockerDest = path.join(projectPath, 'docker');
   fs.cpSync(webSrc, webDest, { recursive: true });
+  fs.cpSync(dockerSrc, dockerDest, { recursive: true });
 
   try {
     execSync(`docker build -f - -t ${imageTag} .`, {
@@ -284,6 +287,7 @@ function buildDockerImage(projectPath) {
     });
   } finally {
     fs.rmSync(webDest, { recursive: true, force: true });
+    fs.rmSync(dockerDest, { recursive: true, force: true });
   }
 
   // Clean up dangling images from previous builds

package/drizzle/0021_coding_agent_workspace.sql

@@ -0,0 +1 @@
+ALTER TABLE `code_workspaces` ADD `coding_agent` text;

package/drizzle/meta/_journal.json

@@ -148,6 +148,13 @@
       "when": 1774327178886,
       "tag": "0020_natural_fabian_cortez",
       "breakpoints": true
+    },
+    {
+      "idx": 21,
+      "version": "6",
+      "when": 1775865600000,
+      "tag": "0021_coding_agent_workspace",
+      "breakpoints": true
     }
   ]
 }

package/lib/ai/index.js

@@ -4,9 +4,16 @@ import { z } from 'zod';
 import { getAgentChat, getCodeChat } from './agent.js';
 import { createModel } from './model.js';
 import path from 'path';
+import { existsSync } from 'fs';
 import { PROJECT_ROOT } from '../paths.js';
 import { render_md } from '../utils/render-md.js';
+import { buildCodingAgentSystemPrompt } from './system-prompt.js';
 import { getChatById, createChat, saveMessage, updateChatTitle, linkChatToWorkspace } from '../db/chats.js';
+import { getConfig } from '../config.js';
+import { getSdkAdapter } from './sdk-adapters/index.js';
+import { ensureWorkspaceRepo, ensureSkills } from './workspace-setup.js';
+import { readSessionId, writeSessionId } from './session-manager.js';
+import { workspaceDir as getWorkspaceDir } from '../tools/docker.js';
 
 /**
  * Ensure a chat exists in the DB and save a message.
@@ -39,6 +46,18 @@ function persistMessage(threadId, role, text, options = {}) {
  * @returns {Promise<string>} AI response text
  */
 async function chat(threadId, message, attachments = [], options = {}) {
+  // SDK path: delegate to chatStream and collect text
+  const sdkAdapter = getSdkAdapter(getConfig('CODING_AGENT'));
+
+  if (sdkAdapter) {
+    let fullText = '';
+    for await (const chunk of chatStream(threadId, message, attachments, options)) {
+      if (chunk.type === 'text') fullText += chunk.text;
+    }
+    return fullText;
+  }
+
+  // Legacy LangGraph path
   const agent = await getAgentChat();
 
   // Save user message to DB
@@ -136,15 +155,131 @@ async function* chatStream(threadId, message, attachments = [], options = {}) {
     workspaceId = workspaceId || existingChat.codeWorkspaceId;
   }
 
-  const agent = isCodeMode
-    ? await getCodeChat()
-    : await getAgentChat();
+  // ── SDK path: direct in-process SDK call (no LangGraph, no Docker) ──
+  const sdkAdapter = getSdkAdapter(getConfig('CODING_AGENT'));
+  const useSDK = !!sdkAdapter;
 
   // Save user message to DB (skip on regeneration — message already exists)
   if (!options.skipUserPersist) {
     persistMessage(threadId, 'user', message || '[attachment]', options);
   }
 
+  if (useSDK) {
+    // 1. Workspace setup (idempotent — skips if .git exists)
+    const wsBaseDir = getWorkspaceDir(workspaceId);
+    const repoDir = path.join(wsBaseDir, 'workspace');
+
+    const { getCodeWorkspaceById } = await import('../db/code-workspaces.js');
+    const workspace = getCodeWorkspaceById(workspaceId);
+    const featureBranch = workspace?.featureBranch;
+
+    const needsSetup = !existsSync(path.join(repoDir, '.git'));
+    const setupToolCallId = `setup-${workspaceId.slice(0, 8)}`;
+    const setupArgs = { repo, branch, featureBranch };
+
+    if (needsSetup) {
+      yield { type: 'tool-call', toolCallId: setupToolCallId, toolName: 'workspace', args: setupArgs };
+    }
+
+    try {
+      const setupOutput = await ensureWorkspaceRepo({ workspaceDir: repoDir, repo, branch, featureBranch });
+      ensureSkills(repoDir, isCodeMode ? 'code' : 'agent');
+      if (needsSetup) {
+        const result = setupOutput || `Workspace ready on ${featureBranch || branch}`;
+        yield { type: 'tool-result', toolCallId: setupToolCallId, result };
+        persistMessage(threadId, 'assistant', JSON.stringify({
+          type: 'tool-invocation',
+          toolCallId: setupToolCallId,
+          toolName: 'workspace',
+          state: 'output-available',
+          input: setupArgs,
+          output: result,
+        }), options);
+      }
+    } catch (err) {
+      if (needsSetup) {
+        yield { type: 'tool-result', toolCallId: setupToolCallId, result: `Setup failed: ${err.message}` };
+      }
+      throw err;
+    }
+
+    // 2. Session continuity
+    const sessionId = readSessionId(wsBaseDir);
+
+    // 3. System prompt
+    const systemPrompt = buildCodingAgentSystemPrompt(isCodeMode ? 'code' : 'agent');
+
+    // 4. Stream from SDK adapter
+    let pendingText = '';
+    const pendingToolCalls = new Map();
+
+    try {
+      for await (const chunk of sdkAdapter({
+        prompt: message,
+        workspaceDir: repoDir,
+        systemPrompt,
+        sessionId,
+        permissionMode: codeModeType,
+        attachments,
+        workspaceId,
+        chatMode: isCodeMode ? 'code' : 'agent',
+      })) {
+        // Write session ID on first meta chunk
+        if (chunk.type === 'meta' && chunk.sessionId) {
+          writeSessionId(wsBaseDir, chunk.sessionId);
+        }
+
+        // DB persistence
+        if (chunk.type === 'text') {
+          pendingText += chunk.text;
+        } else if (chunk.type === 'tool-call') {
+          // Flush accumulated text before tool call
+          if (pendingText) {
+            persistMessage(threadId, 'assistant', pendingText, options);
+            pendingText = '';
+          }
+          pendingToolCalls.set(chunk.toolCallId, { toolName: chunk.toolName, args: chunk.args });
+        } else if (chunk.type === 'tool-result') {
+          const tc = pendingToolCalls.get(chunk.toolCallId);
+          if (tc) {
+            persistMessage(threadId, 'assistant', JSON.stringify({
+              type: 'tool-invocation',
+              toolCallId: chunk.toolCallId,
+              toolName: tc.toolName,
+              state: 'output-available',
+              input: tc.args,
+              output: chunk.result,
+            }), options);
+            pendingToolCalls.delete(chunk.toolCallId);
+          }
+        }
+
+        yield chunk;
+      }
+    } catch (err) {
+      console.error('[chatStream] error:', err);
+      throw err;
+    } finally {
+      // Flush remaining text
+      if (pendingText) {
+        persistMessage(threadId, 'assistant', pendingText, options);
+      }
+    }
+
+    // Auto-generate title for new chats
+    if (options.userId && message) {
+      autoTitle(threadId, message).catch(() => {});
+    }
+
+    return;
+  }
+
+  // ── Legacy path: LangGraph + Docker (non-claude-code agents + job mode) ──
+
+  const agent = isCodeMode
+    ? await getCodeChat()
+    : await getAgentChat();
+
   // Build content blocks: text + any image/PDF attachments as vision
   const content = [];
 

package/lib/ai/model.js

@@ -118,6 +118,12 @@ export async function createModel(options = {}) {
       if (!apiKey) throw new Error(LLM_NOT_CONFIGURED);
       return new ChatOpenAI({ modelName, maxTokens, apiKey, configuration: { baseURL: 'https://openrouter.ai/api/v1' } });
     }
+    case 'nvidia': {
+      const { ChatOpenAI } = await import('@langchain/openai');
+      const apiKey = getConfig('NVIDIA_API_KEY');
+      if (!apiKey) throw new Error(LLM_NOT_CONFIGURED);
+      return new ChatOpenAI({ modelName, maxTokens, apiKey, configuration: { baseURL: 'https://integrate.api.nvidia.com/v1' } });
+    }
     default:
       throw new Error(`Unknown LLM provider: ${provider}`);
   }

package/lib/ai/sdk-adapters/CLAUDE.md

@@ -0,0 +1,113 @@
+# lib/ai/sdk-adapters/ — SDK Adapter System
+
+In-process SDK adapters that replace the legacy LangGraph + Docker path for chat. Each adapter wraps a coding agent's SDK and yields a unified chunk stream consumed by `chatStream()` in `lib/ai/index.js`.
+
+## Architecture
+
+```
+Browser → POST /stream/chat (api.js)
+  → chatStream() (index.js)
+    → getSdkAdapter() returns adapter function or null
+    → if adapter: workspace setup → SDK adapter streaming → DB persistence
+    → if null: falls back to legacy LangGraph/Docker path
+```
+
+The adapter is a pure stream translator — it receives a prompt and options, calls the SDK, and yields normalized chunks. Everything else (workspace setup, DB persistence, session continuity, system prompts) is handled by `chatStream()` in `index.js`.
+
+## Existing Adapter
+
+| File | Agent | SDK |
+|------|-------|-----|
+| `claude-code.js` | `claude-code` | `@anthropic-ai/claude-agent-sdk` |
+
+## Adding a New SDK Adapter
+
+### 1. Create the adapter file
+
+Create `{agent-name}.js` in this directory. Export a single async generator function:
+
+```js
+export async function* myAgentStream({ prompt, workspaceDir, systemPrompt, sessionId, permissionMode, attachments }) {
+  // ... call the SDK, yield chunks
+}
+```
+
+### 2. Required chunk types to yield
+
+The adapter MUST yield these chunk types for `chatStream()` and `api.js` to work correctly:
+
+| Chunk | Shape | When | Purpose |
+|-------|-------|------|---------|
+| `meta` | `{ type: 'meta', sessionId: string }` | First event | Session ID for continuity across messages. `chatStream()` writes this to disk via `writeSessionId()` so subsequent messages resume the session. |
+| `text` | `{ type: 'text', text: string }` | Text output | Streamed to UI as deltas. Accumulated by `chatStream()` and flushed to DB as assistant messages at tool boundaries and stream end. |
+| `tool-call` | `{ type: 'tool-call', toolCallId: string, toolName: string, args: object }` | Tool invocation starts | Triggers tool UI in the browser. May be yielded twice: once at start with `args: {}`, once at `content_block_stop` with complete args. `chatStream()` tracks these in `pendingToolCalls` for pairing with results. |
+| `tool-result` | `{ type: 'tool-result', toolCallId: string, result: string }` | Tool completes | Paired with the matching `tool-call` by `toolCallId`. `chatStream()` persists the pair as a `tool-invocation` JSON message in the DB. |
+| `result` | `{ type: 'result', text: string, cost?: number, duration?: number, subtype?: string }` | Stream ends | Final summary. Logged by `chatStream()`, not persisted or sent to UI. |
+
+Optional:
+| `unknown` | `{ type: 'unknown', raw: any }` | Unrecognized events | `api.js` renders these as collapsible boxes in the UI. Use for debugging unhandled SDK events. |
+
+### 3. Register in index.js
+
+Add the import and mapping in `getSdkAdapter()`:
+
+```js
+import { myAgentStream } from './my-agent.js';
+
+export function getSdkAdapter(agentType) {
+  if (agentType === 'claude-code') return claudeCodeStream;
+  if (agentType === 'my-agent') return myAgentStream;
+  return null;
+}
+```
+
+The `agentType` string comes from the `CODING_AGENT` config value set in the admin UI.
+
+### 4. Auth resolution
+
+Use `buildAgentAuthEnv(agentType)` from `lib/tools/docker.js` to get credentials from the settings DB. This returns `{ env: string[], backendApi: string }` where `env` is an array of `KEY=value` strings. Parse them into an env object:
+
+```js
+import { buildAgentAuthEnv } from '../../tools/docker.js';
+
+const env = { ...process.env };
+const { env: authEnvPairs } = buildAgentAuthEnv('my-agent');
+for (const pair of authEnvPairs) {
+  const eqIdx = pair.indexOf('=');
+  if (eqIdx > 0) env[pair.slice(0, eqIdx)] = pair.slice(eqIdx + 1);
+}
+```
+
+The agent's auth config (API keys, OAuth tokens, provider selection) is managed in the admin UI at `/admin/event-handler/coding-agents` and stored in the settings DB. `buildAgentAuthEnv()` reads it — you don't need to access the settings DB directly.
+
+### 5. Function parameters
+
+| Param | Type | Description |
+|-------|------|-------------|
+| `prompt` | `string` | User message text |
+| `workspaceDir` | `string` | Absolute path to git repo root (the SDK should execute here) |
+| `systemPrompt` | `string\|null` | System prompt for agent mode (null in code mode) |
+| `sessionId` | `string\|null` | Previous session ID to resume (null on first message) |
+| `permissionMode` | `string` | `'plan'` (read-only) or `'code'` (read-write). Map to the SDK's equivalent permission concept. |
+| `attachments` | `Array` | Image attachments: `{ category: 'image', mimeType, dataUrl }` |
+
+### 6. Session continuity contract
+
+Multi-turn conversation works via session IDs:
+
+1. First message: `sessionId` param is `null`. Adapter yields `{ type: 'meta', sessionId: '<new-id>' }`.
+2. `chatStream()` writes the session ID to `{workspaceBaseDir}/.claude-ttyd-sessions/7681`.
+3. Next message: `sessionId` param contains the saved ID. Adapter passes it to the SDK's resume mechanism.
+
+If the SDK doesn't support session resume, the adapter can ignore `sessionId` — but multi-turn context will be lost between messages.
+
+## What the adapter does NOT handle
+
+These are managed by `chatStream()` in `index.js` — adapters should not duplicate them:
+
+- **Workspace git setup** — `ensureWorkspaceRepo()` clones/checkouts before the adapter is called
+- **DB persistence** — `chatStream()` saves user messages, assistant text, and tool invocations
+- **Chat creation** — `chatStream()` creates the chat and workspace DB records
+- **Auto-titling** — `chatStream()` generates a title after the first message
+- **System prompt loading** — `chatStream()` calls `buildCodingAgentSystemPrompt()` and passes the result as `systemPrompt`
+- **Skill activation** — `ensureSkills()` runs before the adapter is called