@inceptionstack/roundhouse 0.5.15 → 0.5.17

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@inceptionstack/roundhouse",
-  "version": "0.5.15",
+  "version": "0.5.17",
   "type": "module",
   "description": "Multi-platform chat gateway that routes messages through a configured AI agent",
   "license": "MIT",

package/src/gateway/gateway.ts

@@ -25,6 +25,7 @@ import { handleStreaming as _handleStream } from "./streaming";
 import { handleNew, handleRestart, handleUpdate, handleCompact, handleStatus, handleStop, handleVerbose, handleDoctor, handleCrons, type CommandContext } from "./commands";
 import { handleModel, handleModelAction, MODEL_ACTION_ID } from "./model-command";
 import { handleLater } from "./later-command";
+import { handleTopic, applyTopicOverride } from "./topic-command";
 import { TelegramAdapter } from "../transports";
 import type { TransportAdapter } from "../transports";
 import { hostname } from "node:os";
@@ -215,7 +216,7 @@ export class Gateway {
 
     // ── Unified handler ────────────────────────────
     const handle = async (thread: any, message: any) => {
-      const agentThreadId = resolveAgentThreadId(thread, message);
+      let agentThreadId = applyTopicOverride(resolveAgentThreadId(thread, message), thread);
       const userText = message.text ?? "";
       const authorName = message.author?.userName ?? message.author?.userId ?? "?";
       const rawAttachments = message.attachments ?? [];
@@ -267,13 +268,18 @@ export class Gateway {
         return;
       }
 
+      if (isCommandWithArgs(trimmed, "/topic") || isCommand(trimmed, "/topic")) {
+        await handleTopic({ thread, text: trimmed, postWithFallback: (t, txt) => this.postWithFallback(t, txt) });
+        return;
+      }
+
       // Dispatch to agent turn handler
       await this.handleAgentTurn(thread, agentThreadId, userText, rawAttachments, verboseThreads, threadLocks, abortControllers);
     };
 
     // ── Wire Chat SDK events ───────────────────────
     const handleOrAbort = async (thread: any, message: any) => {
-      const agentThreadId = resolveAgentThreadId(thread, message);
+      let agentThreadId = applyTopicOverride(resolveAgentThreadId(thread, message), thread);
       const text = (message.text ?? "").trim();
       // /stop — abort the in-flight agent run immediately
       if (isCommand(text, "/stop")) {

package/src/gateway/helpers.ts

@@ -51,21 +51,40 @@ function getChatId(thread: any, message: any): string {
 
 /**
  * Resolve the agent-facing thread ID from a chat message.
- * Private/DM → "main", group → "group:<chatId>"
+ * Private/DM → "main", group → "group:<chatId>", forum topic → "group:<chatId>:topic:<topicId>"
  */
 export function resolveAgentThreadId(thread: any, message: any): string {
   const chatType = String(message?.chat?.type ?? thread?.chat?.type ?? thread?.type ?? "").toLowerCase();
+  
+  // Extract topic ID if present (forum threads)
+  const topicId = message?.message_thread_id ?? thread?.messageThreadId ?? extractTopicFromThreadId(thread?.id);
+  
   if (["private", "dm", "direct", "im"].includes(chatType)) return "main";
-  if (["group", "supergroup", "channel"].includes(chatType)) return `group:${getChatId(thread, message)}`;
+  if (["group", "supergroup", "channel"].includes(chatType)) {
+    const base = `group:${getChatId(thread, message)}`;
+    return topicId ? `${base}:topic:${topicId}` : base;
+  }
 
   const telegramChatId = telegramChatIdFromThreadId(thread?.id);
   if (telegramChatId !== null) {
-    return telegramChatId < 0 ? `group:${telegramChatId}` : "main";
+    const base = telegramChatId < 0 ? `group:${telegramChatId}` : "main";
+    return (topicId && telegramChatId < 0) ? `${base}:topic:${topicId}` : base;
   }
 
   return String(thread?.id ?? "main");
 }
 
+/** Extract message_thread_id from thread ID string like "telegram:chatId:topicId" */
+function extractTopicFromThreadId(threadId: string | undefined): number | undefined {
+  if (!threadId) return undefined;
+  const parts = threadId.split(":");
+  if (parts.length === 3 && parts[0] === "telegram") {
+    const parsed = parseInt(parts[2], 10);
+    return Number.isFinite(parsed) ? parsed : undefined;
+  }
+  return undefined;
+}
+
 // ── System Resources ─────────────────────────────────
 
 export interface SystemResources {

package/src/gateway/topic-command.ts

@@ -0,0 +1,117 @@
+/**
+ * gateway/topic-command.ts — Named topic sessions in private chats
+ *
+ * Allows switching between independent conversations via /topic <name>.
+ * Each topic has its own agent session (memory, context, thread).
+ *
+ * Usage:
+ *   /topic deploy    — switch to "deploy" topic (creates if new)
+ *   /topic           — show current topic + list all
+ *   /topic main      — return to default session
+ */
+
+import { readFileSync, writeFileSync, mkdirSync, readdirSync, renameSync } from "node:fs";
+import { join } from "node:path";
+import { randomBytes } from "node:crypto";
+import { ROUNDHOUSE_DIR } from "../config";
+
+const TOPICS_FILE = join(ROUNDHOUSE_DIR, "active-topics.json");
+
+/** Active topic per chat (chatId → topicName). "main" means default. */
+let activeTopics = new Map<string, string>();
+
+// Load persisted topics on module init
+try {
+  const data = JSON.parse(readFileSync(TOPICS_FILE, "utf8"));
+  activeTopics = new Map(Object.entries(data));
+} catch { /* first run or corrupt — start fresh */ }
+
+function persistTopics(): void {
+  try {
+    mkdirSync(ROUNDHOUSE_DIR, { recursive: true });
+    const tmp = TOPICS_FILE + "." + randomBytes(4).toString("hex");
+    writeFileSync(tmp, JSON.stringify(Object.fromEntries(activeTopics)));
+    renameSync(tmp, TOPICS_FILE);
+  } catch (e) { console.error("[roundhouse] failed to persist topics:", e); }
+}
+
+/** Get the active topic for a chat. Returns undefined if on default "main". */
+export function getActiveTopic(chatId: string): string | undefined {
+  const topic = activeTopics.get(chatId);
+  return (topic && topic !== "main") ? topic : undefined;
+}
+
+/** Apply topic override to a resolved agent thread ID. Scoped per chat. */
+export function applyTopicOverride(agentThreadId: string, thread: { id?: string }): string {
+  if (agentThreadId !== "main") return agentThreadId;
+  const chatId = thread.id?.split(":")[1] ?? thread.id ?? "";
+  const topic = getActiveTopic(String(chatId));
+  return topic ? `topic:${chatId}:${topic}` : agentThreadId;
+}
+
+/** Set the active topic for a chat. */
+export function setActiveTopic(chatId: string, topic: string): void {
+  if (topic === "main" || topic === "off" || topic === "") {
+    activeTopics.delete(chatId);
+  } else {
+    activeTopics.set(chatId, topic);
+  }
+  persistTopics();
+}
+
+/** Get all known topics for a specific chat from memory-state directory. */
+export function listTopics(chatId: string): string[] {
+  const stateDir = join(ROUNDHOUSE_DIR, "memory-state");
+  // Files are named topic_c<chatId>_c<topicName>.json (threadIdToDir encoding)
+  const prefix = `topic_c${chatId}_c`;
+  try {
+    return readdirSync(stateDir)
+      .filter(f => f.startsWith(prefix) && f.endsWith(".json"))
+      .map(f => f.slice(prefix.length).replace(/\.json$/, ""))
+      .map(f => f.replace(/__/g, "_")); // reverse threadIdToDir underscore encoding
+  } catch {
+    return [];
+  }
+}
+
+export interface TopicCommandContext {
+  thread: { id: string };
+  text: string;
+  postWithFallback: (thread: any, text: string) => Promise<void>;
+}
+
+export async function handleTopic(ctx: TopicCommandContext): Promise<void> {
+  const { thread, text, postWithFallback } = ctx;
+
+  // Extract chat ID from thread (for private: "telegram:<chatId>")
+  const chatId = thread.id?.split(":")[1] ?? thread.id;
+
+  // /topic only works in private chats (groups use forum topics instead)
+  if (chatId && chatId.startsWith("-")) {
+    await postWithFallback(thread, "⚠️ /topic only works in private chats. Use Telegram forum topics for groups.");
+    return;
+  }
+
+  // Parse the topic name from the command
+  const match = text.match(/^\/topic(?:@\S+)?\s+(.+)/i);
+  const topicName = match?.[1]?.trim().toLowerCase().replace(/[^a-z0-9_-]/g, "-").replace(/^-+|-+$/g, "");
+
+  if (!topicName) {
+    // Show current topic + known topics
+    const current = getActiveTopic(chatId) ?? "main (default)";
+    const known = listTopics(chatId);
+    let msg = `📂 Current topic: \`${current}\`\n\n`;
+    if (known.length > 0) {
+      msg += `Known topics: ${known.map(t => `\`${t}\``).join(", ")}\n\n`;
+    }
+    msg += `Switch with: \`/topic <name>\`\nReturn to default: \`/topic main\``;
+    await postWithFallback(thread, msg);
+    return;
+  }
+
+  setActiveTopic(chatId, topicName);
+  const display = topicName === "main" || topicName === "off" ? "main (default)" : topicName;
+  const isNew = topicName !== "main" && topicName !== "off";
+  const emoji = isNew ? "📂" : "🏠";
+  await postWithFallback(thread, `${emoji} Switched to topic: \`${display}\`\n\nAgent context is now independent for this topic.`);
+}

package/src/transports/telegram/bot-commands.ts

@@ -15,6 +15,7 @@ export const BOT_COMMANDS: BotCommand[] = [
   { command: "compact", description: "Compact context window" },
   { command: "model", description: "Show or switch AI model" },
   { command: "later", description: "Save an idea for later" },
+  { command: "topic", description: "Switch conversation topic" },
   { command: "verbose", description: "Toggle verbose tool output" },
   { command: "stop", description: "Stop the current agent run" },
   { command: "restart", description: "Restart agent process" },