grok-telegram-bot 2.4.0 → 2.6.0

package/src/bot/commands.ts

@@ -1,31 +1,61 @@
 /**
  * Bot command definitions (for the Telegram command menu) and help text.
+ *
+ * Private chats get the full list (sorted by workflow). Groups/forum topics get
+ * a shorter list with cancel/menu first — reply keyboards are unreliable there.
  */
+
+/** Full command menu (private chats + default). Order = Telegram "/" menu order. */
 export const COMMANDS: { command: string; description: string }[] = [
+  // Core control
   { command: "start", description: "Welcome, menu & status panel" },
-  { command: "menu", description: "Show the menu keyboard" },
-  { command: "projects", description: "Projects: list / search <q> / open <path> / new <name>" },
-  { command: "sessions", description: "List/resume sessions (active first) \u00b7 /sessions <q>" },
+  { command: "menu", description: "Open the menu" },
+  { command: "cancel", description: "Stop the current turn" },
+  { command: "stop", description: "Stop the current turn (alias of /cancel)" },
+  { command: "status", description: "Current session, project & queue" },
+  { command: "new", description: "New session in current project" },
+  // Sessions
+  { command: "running", description: "Sessions this chat controls" },
+  { command: "sessions", description: "List/resume sessions · /sessions <q>" },
   { command: "active", description: "Sessions running now on the PC" },
-  { command: "running", description: "Sessions this chat controls \u2014 switch between them" },
-  { command: "import", description: "Import a Kiro/OpenCode/Claude/Codex /running session" },
-  { command: "killall", description: "Kill all active sessions on the PC" },
-  { command: "mcp", description: "Inspect & toggle MCP servers \u00b7 health-check" },
-  { command: "tasks", description: "Manage scheduled tasks" },
-  { command: "newtask", description: "Create a scheduled task" },
   { command: "history", description: "Show recent conversation history" },
-  { command: "new", description: "Start a fresh session here" },
-  { command: "status", description: "Current session, project & queue" },
-  { command: "usage", description: "Account & context usage" },
-  { command: "btw", description: "Run ASAP (now if idle, else next): /btw <text>" },
+  { command: "import", description: "Import Kiro/OpenCode/Claude/Codex session" },
+  // Project
+  { command: "projects", description: "Projects: list / search / open / new" },
+  // Queue
+  { command: "btw", description: "Run ASAP: /btw <text>" },
   { command: "flush", description: "Send queued follow-ups now" },
   { command: "queue", description: "Show queued follow-ups" },
-  { command: "cancel", description: "Stop the current turn" },
-  { command: "unwatch", description: "Stop following a live session" },
+  // Account
+  { command: "accounts", description: "Switch between saved Grok accounts" },
+  { command: "reauth", description: "Sign in to Grok (login or import)" },
+  { command: "usage", description: "Account & context usage" },
+  // System / tools
+  { command: "mcp", description: "Inspect & toggle MCP servers" },
+  { command: "tasks", description: "Manage scheduled tasks" },
+  { command: "newtask", description: "Create a scheduled task" },
+  { command: "killall", description: "Kill all active sessions on the PC" },
   { command: "model", description: "Switch model: /model <id>" },
   { command: "restart", description: "Restart the Grok agent" },
-  { command: "reauth", description: "Sign in to Grok (login or import)" },
-  { command: "accounts", description: "Switch between saved Grok accounts" },
+  { command: "unwatch", description: "Stop following a live session" },
+  { command: "help", description: "Show help" },
+];
+
+/**
+ * Group / forum command menu — keep short; cancel & menu first so topics can
+ * stop a turn without the private reply-keyboard bar.
+ */
+export const GROUP_COMMANDS: { command: string; description: string }[] = [
+  { command: "cancel", description: "Stop the current turn" },
+  { command: "stop", description: "Stop the current turn" },
+  { command: "menu", description: "Open topic / group menu" },
+  { command: "status", description: "Session, project & queue" },
+  { command: "new", description: "New session in this topic/project" },
+  { command: "running", description: "Sessions this topic controls" },
+  { command: "sessions", description: "List / resume sessions" },
+  { command: "btw", description: "Queue or run: /btw <text>" },
+  { command: "flush", description: "Run queued follow-ups now" },
+  { command: "model", description: "Switch model: /model <id>" },
   { command: "help", description: "Show help" },
 ];
 
@@ -37,18 +67,28 @@ export const HELP_TEXT = [
   "\u2022 Just send a message to chat with Grok in the current project.",
   "\u2022 While Grok is working, anything you send is queued and runs",
   "  automatically when the current turn finishes.",
+  "\u2022 Persistent bar (private): \u2630 Menu \u00B7 \u{1F195} New session \u00B7 \u{1F9ED} Running \u00B7 \u23F9 Stop.",
+  "\u2022 New session: /new or the bar button (not the inline Menu message).",
+  "\u2022 In groups / forum topics: use /cancel or Menu \u2192 \u23F9 Stop",
+  "  (the persistent bar is unreliable in topics; use /new or topic menu).",
+  "",
+  "COMMANDS (core)",
+  "/menu \u2014 open the menu",
+  "/cancel or /stop \u2014 stop the current turn",
+  "/status \u2014 session, project and queue",
+  "/new \u2014 new session in the current project (also bar: \u{1F195} New session)",
+  "",
+  "COMMANDS (sessions)",
+  "/running \u2014 sessions this chat/topic controls",
+  "/sessions \u2014 resume a recent Grok session",
+  "/active \u2014 attach to a session running on the PC",
+  "/history \u2014 latest messages of the current session",
+  "/import \u2014 import a /running session from another agent",
   "",
-  "COMMANDS",
-  "/projects \u2014 choose which folder Grok works in",
-  "/sessions \u2014 resume one of your recent Grok sessions",
-  "/active \u2014 attach to a session currently running on the PC",
-  "/import \u2014 import a /running session from Kiro, OpenCode, Claude, or Codex",
-  "/history \u2014 show the latest messages of the current session",
-  "/new \u2014 start a brand-new session in the current project",
-  "/btw <text> \u2014 run it now if idle, otherwise right after the current task",
+  "COMMANDS (more)",
+  "/projects \u2014 choose which folder Grok works in (private chats)",
+  "/btw <text> \u2014 run now if idle, else right after the current task",
   "/flush \u2014 run queued follow-ups immediately",
-  "/cancel \u2014 stop the current turn",
-  "/status \u2014 show session, project and queue size",
-  "/reauth \u2014 sign in to Grok (grok login, or import an existing login)",
-  "/accounts \u2014 switch between saved Grok accounts",
+  "/reauth \u2014 sign in to Grok",
+  "/accounts \u2014 switch saved Grok accounts",
 ].join("\n");

package/src/bot/deps.ts

@@ -18,6 +18,7 @@ import type { TaskRunner } from "../tasks/runner.js";
 import type { TaskStore } from "../tasks/store.js";
 import type { StatusPanel } from "./menu/status-panel.js";
 import type { Ephemeral } from "./menu/ephemeral.js";
+import type { ForumManager } from "../forum/manager.js";
 import type { RuntimeRegistry } from "./registry.js";
 import type { TaskWizard } from "./wizard/task-wizard.js";
 
@@ -38,6 +39,8 @@ export interface BotDeps {
   stt: SttService;
   usage: UsageService;
   accounts: AccountManager;
+  /** Present when TOPIC_GROUP_ID is configured. */
+  forum?: ForumManager;
 }
 
 /** Caches the last project list shown per chat for callback resolution. */

package/src/bot/group-memory.ts

@@ -0,0 +1,339 @@
+/**
+ * Local "group memory" search across forum topics, session metadata, and
+ * recent session history. Telegram bots have no general message-search API,
+ * so this indexes what the bridge already stores on disk.
+ *
+ * Ranking is **relevance + recency**: newer sessions / history win over old
+ * matching text so "what was last worked on" does not surface stale Done notes.
+ */
+import { join } from "node:path";
+import { readHistory } from "../sessions/history.js";
+import type { SessionMeta } from "../sessions/types.js";
+import type { SessionStore } from "../sessions/store.js";
+import type { ForumTopicBinding } from "../forum/types.js";
+
+export type MemoryHitKind = "topic" | "session" | "history";
+
+export interface MemoryHit {
+  kind: MemoryHitKind;
+  title: string;
+  snippet: string;
+  score: number;
+  path?: string;
+  sessionId?: string;
+  threadId?: number;
+  /** Epoch ms for secondary sort / display (session or entry time). */
+  at?: number;
+}
+
+export interface GroupMemorySearchOpts {
+  query: string;
+  limit?: number;
+  sessionsDir: string;
+  store: SessionStore;
+  topics?: ForumTopicBinding[];
+  /** Max sessions whose JSONL tails are scanned. */
+  maxSessions?: number;
+  /**
+   * Prefer sessions under these paths (e.g. workspace for General, then a
+   * project path). Earlier paths get a higher score boost.
+   */
+  preferPaths?: string[];
+  /** Boost history from sessions whose title/comment looks like General manager. */
+  preferGeneral?: boolean;
+}
+
+/** Tokenize a query into lowercase alphanumeric tokens (min length 2). */
+export function tokenizeQuery(query: string): string[] {
+  return query
+    .toLowerCase()
+    .split(/[^a-z0-9_./\\-]+/i)
+    .map((t) => t.trim())
+    .filter((t) => t.length >= 2)
+    .slice(0, 12);
+}
+
+/** Score how well `haystack` matches tokens (0 if no token hits). */
+export function scoreTokens(haystack: string, tokens: string[]): number {
+  if (!tokens.length || !haystack) return 0;
+  const h = haystack.toLowerCase();
+  let score = 0;
+  let hits = 0;
+  for (const t of tokens) {
+    if (!h.includes(t)) continue;
+    hits++;
+    // Prefer whole-word-ish hits slightly.
+    const re = new RegExp(`(?:^|[^a-z0-9])${escapeReg(t)}(?:[^a-z0-9]|$)`, "i");
+    score += re.test(h) ? 3 : 1;
+    // Density bonus for short fields.
+    if (h.length < 120) score += 1;
+  }
+  if (hits === 0) return 0;
+  // All-token bonus.
+  if (hits === tokens.length) score += 4;
+  return score;
+}
+
+/**
+ * True when the user is asking what happened *recently* (last mods, last work).
+ * These queries weight recency much higher than pure text match.
+ * Avoid bare "work"/"done" — those appear in many normal asks and would
+ * over-prioritize recency over relevance.
+ */
+export function queryWantsRecency(query: string): boolean {
+  return /\b(last|latest|recent|newest|today|yesterday|modif(?:y|ied|ication|ications)?|changes?|changed|updated|what\s+was|what\s+did|last\s+work|recent\s+work|last\s+done)\b/i.test(
+    query,
+  );
+}
+
+/**
+ * Normalize epoch seconds vs milliseconds (or ISO string) to ms.
+ * Returns undefined when missing/invalid (never NaN).
+ */
+export function normalizeEpochMs(
+  value: string | number | undefined,
+): number | undefined {
+  if (value === undefined || value === null || value === "") return undefined;
+  let t: number;
+  if (typeof value === "number") {
+    t = value;
+  } else {
+    t = Date.parse(value);
+  }
+  if (!Number.isFinite(t) || t <= 0) return undefined;
+  // Seconds since epoch (~1e9) → ms. ms since epoch is ~1e12+.
+  if (t > 0 && t < 1e11) t *= 1000;
+  if (!Number.isFinite(t) || t <= 0) return undefined;
+  return t;
+}
+
+/**
+ * Recency score 0–20 from an updatedAt ISO string or epoch ms/seconds.
+ * <1h:20, <6h:16, <24h:12, <3d:8, <7d:4, <30d:2, older:0.
+ */
+export function recencyBoost(updatedAt: string | number | undefined, now = Date.now()): number {
+  const t = normalizeEpochMs(updatedAt);
+  if (t === undefined) return 0;
+  const ageH = Math.max(0, (now - t) / 3_600_000);
+  if (ageH < 1) return 20;
+  if (ageH < 6) return 16;
+  if (ageH < 24) return 12;
+  if (ageH < 72) return 8;
+  if (ageH < 168) return 4;
+  if (ageH < 720) return 2;
+  return 0;
+}
+
+/** Human-ish age for snippets. */
+export function formatAge(at: number | undefined, now = Date.now()): string {
+  if (!at || !Number.isFinite(at)) return "";
+  const mins = Math.max(0, Math.round((now - at) / 60_000));
+  if (mins < 60) return `${mins}m ago`;
+  const hours = Math.round(mins / 60);
+  if (hours < 48) return `${hours}h ago`;
+  const days = Math.round(hours / 24);
+  return `${days}d ago`;
+}
+
+/**
+ * Search topics + session store + recent history. Pure ranking over provided
+ * store; safe to call on the main bot thread (capped I/O).
+ *
+ * Sort key: score (relevance + recency) DESC, then `at` DESC (newest first).
+ */
+export function searchGroupMemory(opts: GroupMemorySearchOpts): MemoryHit[] {
+  const tokens = tokenizeQuery(opts.query);
+  if (tokens.length === 0) return [];
+  const limit = Math.max(1, Math.min(20, opts.limit ?? 8));
+  const maxSessions = opts.maxSessions ?? 40;
+  const now = Date.now();
+  const wantsRecent = queryWantsRecency(opts.query);
+  /** Multiply recency when user asks for last/recent work. */
+  const recencyMul = wantsRecent ? 2.5 : 1.2;
+  const hits: MemoryHit[] = [];
+
+  for (const t of opts.topics ?? []) {
+    const hay = [t.name, t.projectPath ?? "", t.kind, t.sessionId ?? ""].join("\n");
+    const score = scoreTokens(hay, tokens);
+    if (score <= 0) continue;
+    // Topic map updatedAt is already epoch ms.
+    const at = normalizeEpochMs(t.updatedAt);
+    // Mild recency on topics (routing), not full "last work" weight.
+    const r = recencyBoost(at, now) * Math.min(1.2, recencyMul);
+    hits.push({
+      kind: "topic",
+      title: t.name,
+      snippet: t.projectPath ? `path: ${t.projectPath}` : `kind: ${t.kind}`,
+      score: score + 2 + r,
+      path: t.projectPath ?? undefined,
+      threadId: t.threadId,
+      sessionId: t.sessionId,
+      at,
+    });
+  }
+
+  let metas: SessionMeta[] = [];
+  try {
+    // Store already returns most-recently-updated first.
+    metas = opts.store.list(maxSessions);
+  } catch {
+    metas = [];
+  }
+
+  const prefer = (opts.preferPaths ?? []).map((p) => p.replace(/\\/g, "/").toLowerCase());
+
+  // Per project path: which session is the newest (for "last work in X").
+  const newestByCwd = new Map<string, number>();
+  for (const m of metas) {
+    const key = normPath(m.cwd);
+    if (!key) continue;
+    const t = normalizeEpochMs(m.updatedAt) ?? 0;
+    const prev = newestByCwd.get(key) ?? 0;
+    if (t > prev) newestByCwd.set(key, t);
+  }
+
+  for (const m of metas) {
+    const pathBoost = pathPreferenceBoost(m.cwd, prefer);
+    const generalBoost =
+      opts.preferGeneral &&
+      (/^general$/i.test(m.title || "") || /general/i.test(m.comment || ""))
+        ? 5
+        : 0;
+    const sessionAt = normalizeEpochMs(m.updatedAt);
+    const rBoost = recencyBoost(sessionAt, now) * recencyMul;
+    const newestBoost =
+      sessionAt !== undefined && newestByCwd.get(normPath(m.cwd)) === sessionAt ? 10 : 0;
+
+    const hay = [m.title, m.comment ?? "", m.cwd, m.sessionId].join("\n");
+    const base = scoreTokens(hay, tokens);
+    // Require text relevance — path/recency alone never invents a hit.
+    if (base <= 0) {
+      // Still scan history below if the session might contain matching tails.
+    }
+    const score = base + pathBoost + generalBoost + rBoost + newestBoost;
+    const age = formatAge(sessionAt, now);
+
+    if (base > 0 && Number.isFinite(score) && score > 0) {
+      hits.push({
+        kind: "session",
+        title: m.title || m.sessionId.slice(0, 8),
+        snippet: clamp(
+          [age ? `[${age}]` : "", m.comment, m.cwd].filter(Boolean).join(" · ") || m.sessionId,
+          240,
+        ),
+        score,
+        path: m.cwd || undefined,
+        sessionId: m.sessionId,
+        at: sessionAt,
+      });
+    }
+
+    // History: deeper tail for recent or path-matched sessions.
+    const histDepth =
+      rBoost >= 12 || pathBoost + generalBoost > 0 || wantsRecent ? 28 : 14;
+    if (m.historyBytes <= 0) continue;
+    try {
+      const path = join(opts.sessionsDir, `${m.sessionId}.jsonl`);
+      const entries = readHistory(path, histDepth);
+      // Prefer newer entries: history is oldest→newest; weight later indices.
+      const n = entries.length;
+      for (let i = 0; i < n; i++) {
+        const e = entries[i]!;
+        if (!e.text?.trim()) continue;
+        // Skip meta dumps that pollute "last work" answers.
+        if (/MANAGER CONTEXT \(auto/i.test(e.text)) continue;
+        if (/^COMPLEXITY \(decide yourself/i.test(e.text)) continue;
+        if (/TELEGRAM BRIDGE \(how to work/i.test(e.text)) continue;
+
+        const textScore = scoreTokens(e.text, tokens);
+        if (textScore <= 0) continue;
+
+        // Prefer entry timestamp; fall back to session updatedAt (not 0/NaN).
+        const entryAt = normalizeEpochMs(e.timestamp) ?? sessionAt;
+        const entryRecency = recencyBoost(entryAt, now) * recencyMul;
+        // Position boost: last entries in the tail are newest.
+        const posBoost = n > 1 ? Math.round((i / (n - 1)) * 6) : 3;
+        // Prefer user prompts + assistant Done prose for "what was last done".
+        const roleBoost = e.role === "user" ? 3 : e.role === "assistant" ? 3 : 0;
+        const s =
+          textScore +
+          pathBoost +
+          generalBoost +
+          entryRecency +
+          posBoost +
+          roleBoost +
+          (newestBoost > 0 ? 4 : 0);
+        if (!Number.isFinite(s) || s <= 0) continue;
+        const eAge = formatAge(entryAt, now);
+        hits.push({
+          kind: "history",
+          title: `${e.role} · ${(m.title || m.sessionId.slice(0, 8)).slice(0, 40)}`,
+          snippet: clamp(
+            [eAge ? `[${eAge}]` : "", e.text.replace(/\s+/g, " ").trim()].filter(Boolean).join(" "),
+            240,
+          ),
+          score: s,
+          path: m.cwd || undefined,
+          sessionId: m.sessionId,
+          at: entryAt,
+        });
+      }
+    } catch {
+      /* ignore unreadable logs */
+    }
+  }
+
+  // Newest high scores first.
+  hits.sort(
+    (a, b) =>
+      b.score - a.score ||
+      (b.at ?? 0) - (a.at ?? 0) ||
+      a.kind.localeCompare(b.kind),
+  );
+  // Dedupe near-identical snippets.
+  const seen = new Set<string>();
+  const out: MemoryHit[] = [];
+  for (const h of hits) {
+    const key = `${h.kind}|${h.sessionId ?? h.threadId ?? ""}|${h.snippet.slice(0, 80)}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    out.push(h);
+    if (out.length >= limit) break;
+  }
+  return out;
+}
+
+function clamp(s: string, max: number): string {
+  if (s.length <= max) return s;
+  return s.slice(0, max - 1) + "\u2026";
+}
+
+function escapeReg(s: string): string {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+function normPath(p: string | undefined): string {
+  if (!p) return "";
+  return p.replace(/\\/g, "/").replace(/\/+$/, "").toLowerCase();
+}
+
+/**
+ * Higher boost for earlier preferred paths.
+ * Index 0 is usually the workspace (General) — use **exact** match only so we
+ * do not treat every child project under Domains as "General memory".
+ * Later entries (project paths) allow prefix match.
+ */
+function pathPreferenceBoost(cwd: string | undefined, prefer: string[]): number {
+  if (!cwd || prefer.length === 0) return 0;
+  const n = cwd.replace(/\\/g, "/").toLowerCase();
+  for (let i = 0; i < prefer.length; i++) {
+    const p = prefer[i]!.replace(/\\/g, "/").toLowerCase();
+    if (!p) continue;
+    const exact = n === p;
+    const child = i > 0 && (n === p || n.startsWith(p + "/"));
+    if (exact || child) {
+      return 8 - Math.min(6, i * 2);
+    }
+  }
+  return 0;
+}

package/src/bot/handlers/accounts.ts

@@ -294,6 +294,13 @@ export function registerAccounts(bot: Bot, deps: BotDeps): void {
         await deps.acp.start(true).catch(() => {});
         throw e;
       }
+      // Remember preferred account for this chat/topic scope (model/reasoning peers).
+      try {
+        const { resolveScope } = await import("../scope.js");
+        resolveScope(ctx, deps).rt.setPreferredAccountId(id);
+      } catch {
+        /* non-fatal */
+      }
       const note = (await deps.usage.isLoggedIn())
         ? `\u2705 Now signed in as ${meta.label}. Your next message runs on this account.`
         : `\u26A0\uFE0F Switched to ${meta.label}, but no usable login is active. ${UNSUPPORTED_LOGIN_HELP}`;