@inceptionstack/roundhouse 0.5.14 → 0.5.16

package/CHANGELOG.md

@@ -2,6 +2,40 @@
 
 All notable changes to `@inceptionstack/roundhouse` are documented here.
 
+## [0.5.14] — 2026-05-10
+
+### Added
+- **"What's New" notification** — after `/update` + restart, startup message shows changelog highlights from the new version
+- Command dispatch registry — cleaner gateway routing (−13 lines)
+- Status helpers extracted (`formatUptime`, `checkAvailableUpdate`)
+
+### Fixed
+- COMMAND_REGISTRY type safety (`CommandContext` not `any`)
+- CHANGELOG.md now included in published npm package
+
+## [0.5.13] — 2026-05-10
+
+### Added
+- **soul.md + user.md persona injection** — agent identity + user context, auto-reloads on file change
+- tools.md now hints agent to check `~/.roundhouse/workspace/later.md`
+
+### Fixed
+- XML injection: escape `</persona>` in user-supplied persona files
+- `mkdirSync` before `writeSettings` (fixes fresh-install crash)
+- mtime check uses `!==` instead of `>` (catches deletions)
+- `/later@BotName` suffix now stripped in group chats
+
+## [0.5.12] — 2026-05-10
+
+### Added
+- **Inline keyboard for /model** — 8 frontier Bedrock models (2-column, 4-row layout)
+- Models: Claude Opus 4.7, Opus 4.6, Sonnet 4.6, Haiku 4.5, DeepSeek R1, Llama 4, Nova Pro, Mistral Large
+
+## [0.5.11] — 2026-05-09
+
+### Added
+- **/later command** — quick-capture ideas to `~/.roundhouse/workspace/later.md`
+
 ## [0.5.10] — 2026-05-09
 
 ### Fixed

package/package.json

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

package/src/gateway/commands.ts

@@ -68,6 +68,14 @@ export async function handleUpdate(ctx: CommandContext): Promise<void> {
     await thread.post("⚠️ /update requires an allowlist to be configured.");
     return;
   }
+  // Seed .last-version with current version BEFORE update, so new code detects the change on restart
+  try {
+    const { ROUNDHOUSE_DIR, ROUNDHOUSE_VERSION } = await import("../config");
+    const { mkdirSync, writeFileSync } = await import("node:fs");
+    const { join } = await import("node:path");
+    mkdirSync(ROUNDHOUSE_DIR, { recursive: true });
+    writeFileSync(join(ROUNDHOUSE_DIR, ".last-version"), ROUNDHOUSE_VERSION + "\n");
+  } catch {}
   console.log(`[roundhouse] /update requested by @${authorName} in thread=${thread.id}`);
   const progress = await createProgressMessage(thread, "📦 Checking for updates...");
   try {

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,106 @@
+/**
+ * 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 } from "node:fs";
+import { join } from "node:path";
+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 });
+    writeFileSync(TOPICS_FILE, JSON.stringify(Object.fromEntries(activeTopics)));
+  } 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. */
+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:${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 from memory-state directory. */
+export function listTopics(): string[] {
+  const stateDir = join(ROUNDHOUSE_DIR, "memory-state");
+  try {
+    return readdirSync(stateDir)
+      .filter(f => f.startsWith("topic_c") && f.endsWith(".json"))
+      .map(f => f.replace(/^topic_c/, "").replace(/\.json$/, ""))
+      .map(f => f.replace(/__/g, "_")); // reverse threadIdToDir 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;
+
+  // 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();
+    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/gateway/whats-new.ts

@@ -48,12 +48,11 @@ export function checkVersionChange(): string | null {
   // No change
   if (lastVersion === ROUNDHOUSE_VERSION) return null;
 
-  // First run (no previous version)
-  if (!lastVersion) return null;
-
-  // Version changed — this is an update
+  // Version changed (or first run after feature was added) — show what's new
   const changelog = getLatestChangelog();
-  const header = `🆕 Updated: v${lastVersion} → v${ROUNDHOUSE_VERSION}`;
+  const header = lastVersion
+    ? `🆕 Updated: v${lastVersion} → v${ROUNDHOUSE_VERSION}`
+    : `🆕 What's new in v${ROUNDHOUSE_VERSION}`;
   if (!changelog) return header;
   return `${header}\n\n${changelog}`;
 }

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" },