grok-telegram-bot 2.4.0 → 2.5.0

package/src/bot/suggestions.ts

@@ -4,8 +4,10 @@
  * Self-recheck (once per real user turn, when enabled):
  *  1. Hard-skip if no files were modified.
  *  2. Quiet meta ask: AI refuses (simple / pure build / nothing to re-verify)
- *     or writes a focused recheck prompt.
- *  3. That prompt is queued as the one-shot SELF-RECHECK turn.
+ *     or writes a complete recheck brief (bugs + production gaps + finish-all +
+ *     per-bug checklist).
+ *  3. That prompt is queued as the one-shot SELF-RECHECK turn (compose always
+ *     injects finish-all / per-bug rules when the body omitted them).
  *  4. Then Done + suggestions.
  *
  * After Done, the bot quietly asks for 1–3 short next steps as JSON with a
@@ -30,21 +32,36 @@ export const SELF_RECHECK_MARKER = "SELF-RECHECK (automatic quality pass";
 export const DEFAULT_SELF_RECHECK_PROMPT = [
   `${SELF_RECHECK_MARKER} — once only).`,
   "Do a rigorous self-review of the work just completed for the user request below.",
+  "You are a bugs/logic finder AND a production-completeness pass for the SAME feature.",
   "",
-  "You are both a bugs/logic finder AND a completeness checker for related follow-ups.",
-  "Look for:",
-  "1) Bugs, regressions, incomplete steps, wrong assumptions, missing verification, edge cases.",
-  "2) Logical gaps the user would still need — e.g. if they asked for password reset and you",
-  "   shipped the happy path only, also cover brute-force protection, rate limits, token expiry,",
-  "   email enumeration, CSRF, audit logging, and similar security/ops follow-through that a",
-  "   solid implementation of THAT feature should include (not a random new product idea).",
+  "A) Bugs & regressions",
+  "1) Incomplete steps, wrong assumptions, missing verification, edge cases, broken paths.",
+  "2) Logic mismatches (UI vs backend, state vs render, happy path vs error path).",
+  "",
+  "B) Production-related functionality (same domain only — not a new product idea)",
+  "Continue development toward an ideal production version of WHAT WAS BUILT:",
+  "- Game with water → waves/physics/collision where missing; entity that can die → death state; etc.",
+  "- Auth form → rate limits, lockout, CSRF, secure tokens, validation, error handling.",
+  "- API write → input validation, authz, idempotency/errors, logging where expected.",
+  "- UI control → empty/loading/error states, accessibility basics tied to the control.",
+  "Only add what a solid implementation of THIS feature should already include.",
+  "",
+  "C) Finish-all — no honest leftovers",
+  "- Do NOT leave half-done work with 'still need…', 'remaining…', 'TODO for user',",
+  "  incomplete honest footers, or progress stuck low because work is unfinished.",
+  "- Finish critical gaps now so Done does not rely on follow-up suggestion buttons",
+  "  for unfinished must-have work from this request.",
+  "- Do NOT ask the user questions. Do NOT call enter_plan_mode unless truly necessary.",
+  "",
+  "D) Per-bug recheck checklist (REQUIRED at the end of this pass)",
+  "1) List every plausible bug/edge case for THESE changes (race, null, authz, wrong path,",
+  "   regression, missing test, off-by-one, bad default, security hole, etc.).",
+  "2) For each item: verify with tools or fix it. Briefly note only real findings.",
+  "3) Prefer {progress: 100%} only when this checklist is done and nothing critical remains.",
   "",
   "Rules:",
-  "- Prefer fixing real problems with tools when needed; do not invent unrelated features.",
-  "- If something is unfinished relative to the user request (or a tightly related follow-up",
-  "  that leaves the feature incomplete/insecure), finish or fix it now.",
+  "- Prefer fixing real problems with tools; do not invent unrelated features.",
   "- If everything checks out, briefly confirm what you verified (no long essay).",
-  "- Do NOT ask the user questions. Do NOT call enter_plan_mode unless truly necessary.",
   "- End with an honest {progress: N%} marker for this recheck pass.",
   "",
   "USER'S REQUEST:",
@@ -54,6 +71,19 @@ export const DEFAULT_SELF_RECHECK_PROMPT = [
   "{{DONE}}",
 ].join("\n");
 
+/** Shared rules appended when wrapping a short AI-written recheck body. */
+export const SELF_RECHECK_COMPOSE_RULES = [
+  "Rules:",
+  "- Fix real bugs and logic mismatches with tools when needed; no unrelated features.",
+  "- Production-related completeness for the SAME feature (e.g. water→waves, auth→rate limits,",
+  "  API writes→validation/errors). Close gaps a solid production build of this feature needs.",
+  "- Finish-all: do NOT leave 'still need…', 'remaining…', incomplete honest footers, or",
+  "  half-done work that would force critical follow-up buttons. Finish those gaps now.",
+  "- End with a per-bug recheck: list plausible bugs for these changes and verify/fix each.",
+  "- Do NOT ask the user questions. Do NOT call enter_plan_mode unless truly necessary.",
+  "- End with an honest {progress: N%} marker for this recheck pass (100 only when checklist done).",
+].join("\n");
+
 export interface Suggestion {
   /** Plain follow-up the user would type / the bot will submit. */
   text: string;
@@ -231,9 +261,20 @@ export function buildSelfRecheckDecisionPrompt(
     "- Non-trivial code/config changed and edge cases, regressions, or incomplete",
     "  follow-through are plausible (auth, multi-file logic, concurrency, data paths).",
     "- A focused second pass with tools could catch real bugs or finish related gaps.",
+    "- The first pass left honest leftovers ('still need…', unfinished production logic,",
+    "  incomplete feature pieces) that a recheck should finish instead of the user.",
     "",
-    "If needed=true, write a focused recheck prompt: imperative instructions for a one-shot",
-    "second pass that may use tools to fix REAL issues. Do not invent unrelated features.",
+    "If needed=true, write prompt = a COMPLETE recheck brief for a one-shot agent pass.",
+    "The prompt MUST include ALL of the following sections (imperative, concrete, domain-specific):",
+    "1) Bugs/logic: what to re-read, verify, and fix for THIS change set.",
+    "2) Production-related functionality: continue to ideal production for the SAME feature",
+    "   (examples: game water→waves; auth→rate limits/lockout/CSRF; API→validation/errors;",
+    "   UI→empty/loading/error). Not unrelated product ideas.",
+    "3) Finish-all: explicitly order the agent to finish incomplete work and NOT leave",
+    "   'still need…', 'remaining…', incomplete honest footers, or half-done bottoms.",
+    "4) Per-bug recheck (at the BOTTOM of the prompt): list every plausible bug/edge case",
+    "   for these changes and instruct the agent to verify or fix EACH one with tools.",
+    "Do not invent unrelated features. Keep the prompt actionable (not vague).",
     "If needed=false, give a short reason.",
     "",
     "USER'S REQUEST:",
@@ -248,7 +289,7 @@ export function buildSelfRecheckDecisionPrompt(
     "Reply with ONLY one JSON object (no markdown fences, no commentary):",
     '{"needed":false,"reason":"short reason"}',
     "or",
-    '{"needed":true,"prompt":"focused recheck / fix instructions for the agent"}',
+    '{"needed":true,"prompt":"complete recheck brief with bugs + production gaps + finish-all + per-bug checklist"}',
   ].join("\n");
 }
 
@@ -372,6 +413,26 @@ export function buildSelfRecheckPrompt(
   return ensureSelfRecheckMarker(out);
 }
 
+/**
+ * True when the recheck body already encodes finish-all + per-bug expectations
+ * (default template or a strong AI brief). Used to avoid double-appending rules.
+ */
+export function hasSelfRecheckFinishRules(text: string): boolean {
+  const t = text.toLowerCase();
+  const finish =
+    t.includes("still need") || t.includes("finish-all") || t.includes("finish all");
+  const bugs = t.includes("per-bug") || t.includes("plausible bug");
+  return finish && bugs;
+}
+
+/** Append SHARED compose rules when the body omitted finish-all / per-bug language. */
+export function ensureSelfRecheckComposeRules(text: string): string {
+  const body = text.trim();
+  if (!body) return SELF_RECHECK_COMPOSE_RULES;
+  if (hasSelfRecheckFinishRules(body)) return body;
+  return `${body}\n\n${SELF_RECHECK_COMPOSE_RULES}`;
+}
+
 /**
  * Turn an AI-written recheck body into a full one-shot turn (marker + context).
  */
@@ -396,23 +457,22 @@ export function composeSelfRecheckTurn(
     isSelfRecheckPrompt(body) ||
     (/USER'S REQUEST:/i.test(body) && /WHAT WAS JUST DONE/i.test(body));
   if (looksComplete) {
-    return ensureSelfRecheckMarker(body);
+    // Still inject finish-all / per-bug rules if a "complete-looking" AI brief
+    // only copied headers and omitted production/finish-all/per-bug sections.
+    return ensureSelfRecheckMarker(ensureSelfRecheckComposeRules(body));
   }
   return ensureSelfRecheckMarker(
-    [
-      body,
-      "",
-      "Rules:",
-      "- Prefer fixing real problems with tools when needed; do not invent unrelated features.",
-      "- Do NOT ask the user questions. Do NOT call enter_plan_mode unless truly necessary.",
-      "- End with an honest {progress: N%} marker for this recheck pass.",
-      "",
-      "USER'S REQUEST:",
-      user,
-      "",
-      "WHAT WAS JUST DONE (summary):",
-      did,
-    ].join("\n"),
+    ensureSelfRecheckComposeRules(
+      [
+        body,
+        "",
+        "USER'S REQUEST:",
+        user,
+        "",
+        "WHAT WAS JUST DONE (summary):",
+        did,
+      ].join("\n"),
+    ),
   );
 }
 

package/src/bot/telegram-actions.ts

@@ -0,0 +1,440 @@
+/**
+ * Execute agent-requested Telegram bridge actions and produce results +
+ * user-facing status lines.
+ */
+import type { Api } from "grammy";
+import type { AppConfig } from "../config.js";
+import type { ForumManager } from "../forum/manager.js";
+import type { ForumTopicBinding } from "../forum/types.js";
+import { FORUM_GENERAL_THREAD_ID } from "../forum/thread.js";
+import type { SessionStore } from "../sessions/store.js";
+import { createLogger } from "../logger.js";
+import { searchGroupMemory } from "./group-memory.js";
+import type { TelegramBotService } from "./telegram-bots.js";
+import type { TelegramAction } from "../render/telegram-bridge.js";
+
+const log = createLogger("telegram-actions");
+
+/** Cross-topic prompt injection (implemented by bot.ts via registry). */
+export type SubmitTopicPromptFn = (opts: {
+  threadId: number;
+  cwd: string;
+  projectName: string;
+  prompt: string;
+  newSession?: boolean;
+}) => Promise<{ outcome: "ran" | "queued"; sessionId?: string }>;
+
+export interface TelegramActionContext {
+  api: Api;
+  cfg: AppConfig;
+  chatId: number;
+  messageThreadId?: number;
+  forum?: ForumManager;
+  store: SessionStore;
+  bots: TelegramBotService;
+  /** Dispatch a prompt into another forum topic's session. */
+  submitTopicPrompt?: SubmitTopicPromptFn;
+}
+
+export interface TelegramActionResult {
+  action: string;
+  ok: boolean;
+  /** Machine-readable payload for the agent. */
+  data?: unknown;
+  error?: string;
+  /** Short line to show the user (optional). */
+  userNote?: string;
+}
+
+/** Run actions sequentially; bot_command may await a sibling bot. */
+export async function executeTelegramActions(
+  actions: TelegramAction[],
+  ctx: TelegramActionContext,
+): Promise<TelegramActionResult[]> {
+  const results: TelegramActionResult[] = [];
+  for (const action of actions) {
+    try {
+      results.push(await runOne(action, ctx));
+    } catch (e) {
+      const msg = (e as Error).message ?? String(e);
+      log.warn(`action ${action.action} failed: ${msg}`);
+      results.push({ action: action.action, ok: false, error: msg });
+    }
+  }
+  return results;
+}
+
+async function runOne(
+  action: TelegramAction,
+  ctx: TelegramActionContext,
+): Promise<TelegramActionResult> {
+  switch (action.action) {
+    case "create_topic":
+      return createTopic(action, ctx);
+    case "set_path":
+      return setPath(action, ctx);
+    case "send_prompt":
+      return sendPrompt(action, ctx);
+    case "search_memory":
+      return searchMemory(action, ctx);
+    case "list_bots":
+      return listBots(ctx);
+    case "bot_command":
+      return botCommand(action, ctx);
+    default:
+      return { action: "unknown", ok: false, error: "unsupported action" };
+  }
+}
+
+async function createTopic(
+  action: Extract<TelegramAction, { action: "create_topic" }>,
+  ctx: TelegramActionContext,
+): Promise<TelegramActionResult> {
+  const forum = ctx.forum;
+  if (!forum?.isReady) {
+    return {
+      action: "create_topic",
+      ok: false,
+      error:
+        "Forum topics not available (TOPIC_GROUP_ID unset, bot not admin, or Topics disabled)",
+    };
+  }
+  const created = await forum.createBoundTopic(action.name, action.path);
+  if (!created.ok) {
+    return { action: "create_topic", ok: false, error: created.error };
+  }
+  const b = created.binding;
+  return {
+    action: "create_topic",
+    ok: true,
+    data: {
+      threadId: b.threadId,
+      name: b.name,
+      projectPath: b.projectPath,
+      kind: b.kind,
+    },
+    userNote: b.projectPath
+      ? `\u{1F4CC} Created topic **${b.name}** (#${b.threadId}) \u2192 \`${b.projectPath}\``
+      : `\u{1F4CC} Created topic **${b.name}** (#${b.threadId}) (unbound — use set_path)`,
+  };
+}
+
+function setPath(
+  action: Extract<TelegramAction, { action: "set_path" }>,
+  ctx: TelegramActionContext,
+): TelegramActionResult {
+  const forum = ctx.forum;
+  if (!forum?.isReady) {
+    return {
+      action: "set_path",
+      ok: false,
+      error: "Forum topics not available",
+    };
+  }
+  const resolved = resolveTopicRef(forum, action.topic, ctx.cfg);
+  if (!resolved.ok) {
+    return { action: "set_path", ok: false, error: resolved.error };
+  }
+  const { binding } = resolved;
+  if (binding.threadId === FORUM_GENERAL_THREAD_ID) {
+    return {
+      action: "set_path",
+      ok: false,
+      error: "Cannot rebind the General topic (always GROK_WORKSPACE)",
+    };
+  }
+  if (binding.kind === "ai_chat") {
+    return {
+      action: "set_path",
+      ok: false,
+      error: "Cannot rebind the AI Chat topic (always GROK_WORKSPACE)",
+    };
+  }
+
+  // Agent set_path: create missing absolute folders (new project flow).
+  const result = forum.tryBindPath(binding.threadId, action.path, { createIfMissing: true });
+  if (!result.ok) {
+    return { action: "set_path", ok: false, error: result.error };
+  }
+  const b = result.binding;
+  const createdNote = result.created ? " (folder created)" : "";
+  return {
+    action: "set_path",
+    ok: true,
+    data: {
+      threadId: b.threadId,
+      name: b.name,
+      projectPath: b.projectPath,
+      kind: b.kind,
+      created: !!result.created,
+    },
+    userNote: `\u{1F4C1} Topic **${b.name}** (#${b.threadId}) \u2192 \`${b.projectPath}\`${createdNote}`,
+  };
+}
+
+async function sendPrompt(
+  action: Extract<TelegramAction, { action: "send_prompt" }>,
+  ctx: TelegramActionContext,
+): Promise<TelegramActionResult> {
+  const forum = ctx.forum;
+  if (!forum?.isReady) {
+    return {
+      action: "send_prompt",
+      ok: false,
+      error: "Forum topics not available",
+    };
+  }
+  if (!ctx.submitTopicPrompt) {
+    return {
+      action: "send_prompt",
+      ok: false,
+      error: "Cross-topic prompt dispatch is not wired",
+    };
+  }
+
+  const resolved = resolveTopicRef(forum, action.topic, ctx.cfg);
+  if (!resolved.ok) {
+    return { action: "send_prompt", ok: false, error: resolved.error };
+  }
+  const { binding } = resolved;
+  const cwd = binding.projectPath;
+  if (!cwd) {
+    return {
+      action: "send_prompt",
+      ok: false,
+      error: `Topic **${binding.name}** (#${binding.threadId}) has no project path — use set_path or create_topic with path first`,
+    };
+  }
+
+  const projectName =
+    binding.kind === "ai_chat"
+      ? ctx.cfg.topicAiChatName
+      : binding.kind === "general"
+        ? "General"
+        : binding.name;
+
+  // Visible injection in the *target* topic so humans see the orchestrated prompt.
+  // Plain text (no Markdown) so agent prompts with * _ ` cannot break the send.
+  const preview =
+    action.prompt.length > 1500 ? action.prompt.slice(0, 1499) + "\u2026" : action.prompt;
+  await ctx.api
+    .sendMessage(
+      forum.groupId,
+      `\u{1F4E8} Prompt from bridge${action.newSession ? " (new session)" : ""}\n\n${preview}`,
+      { message_thread_id: binding.threadId },
+    )
+    .catch((e) => {
+      log.debug(`send_prompt announce failed: ${(e as Error).message}`);
+    });
+
+  try {
+    const res = await ctx.submitTopicPrompt({
+      threadId: binding.threadId,
+      cwd,
+      projectName,
+      prompt: action.prompt,
+      newSession: action.newSession,
+    });
+    return {
+      action: "send_prompt",
+      ok: true,
+      data: {
+        threadId: binding.threadId,
+        name: binding.name,
+        projectPath: cwd,
+        outcome: res.outcome,
+        sessionId: res.sessionId,
+        newSession: !!action.newSession,
+        promptPreview: action.prompt.slice(0, 200),
+      },
+      userNote: `\u{1F4E8} Prompt ${res.outcome} in **${binding.name}** (#${binding.threadId})`,
+    };
+  } catch (e) {
+    return {
+      action: "send_prompt",
+      ok: false,
+      error: (e as Error).message ?? String(e),
+      data: { threadId: binding.threadId, name: binding.name, projectPath: cwd },
+    };
+  }
+}
+
+/**
+ * Resolve a topic ref: numeric / #id, "general", "ai chat", or exact title.
+ */
+export function resolveTopicRef(
+  forum: ForumManager,
+  ref: string,
+  cfg: AppConfig,
+): { ok: true; binding: ForumTopicBinding } | { ok: false; error: string } {
+  const raw = ref.trim();
+  if (!raw) return { ok: false, error: "Empty topic reference" };
+
+  // #123 or plain digits
+  const idMatch = /^#?(\d+)$/.exec(raw);
+  if (idMatch) {
+    const threadId = Number(idMatch[1]);
+    const b = forum.store.get(threadId);
+    if (!b) {
+      // General (1) may not be in store yet — synthesize workspace bind.
+      if (threadId === FORUM_GENERAL_THREAD_ID) {
+        const bound = forum.store.bindProject(threadId, cfg.workspace, "General", "general");
+        return { ok: true, binding: bound };
+      }
+      return { ok: false, error: `No topic mapped for thread #${threadId}` };
+    }
+    return { ok: true, binding: b };
+  }
+
+  const key = raw.toLowerCase();
+  if (key === "general" || key === "general topic") {
+    let b = forum.store.get(FORUM_GENERAL_THREAD_ID);
+    if (!b?.projectPath) {
+      b = forum.store.bindProject(FORUM_GENERAL_THREAD_ID, cfg.workspace, "General", "general");
+    }
+    return { ok: true, binding: b };
+  }
+
+  const aiName = (cfg.topicAiChatName || "AI Chat").toLowerCase();
+  if (key === "ai chat" || key === "ai_chat" || key === aiName) {
+    const ai = forum.store.findAiChat();
+    if (ai) return { ok: true, binding: ai };
+    // Fallback: ensure workspace topic by name match
+    const byName = forum.store.all().find((t) => t.name.toLowerCase() === aiName);
+    if (byName) return { ok: true, binding: byName };
+    return { ok: false, error: "AI Chat topic not found — run /forum_setup" };
+  }
+
+  // Exact title match (case-insensitive)
+  const hits = forum.store.all().filter((t) => t.name.toLowerCase() === key);
+  if (hits.length === 1) return { ok: true, binding: hits[0]! };
+  if (hits.length > 1) {
+    return {
+      ok: false,
+      error: `Multiple topics named "${raw}" (${hits.map((h) => "#" + h.threadId).join(", ")}). Use #threadId.`,
+    };
+  }
+  return {
+    ok: false,
+    error: `Topic not found: "${raw}". Use exact title, #threadId, "general", or "ai chat".`,
+  };
+}
+
+function searchMemory(
+  action: Extract<TelegramAction, { action: "search_memory" }>,
+  ctx: TelegramActionContext,
+): TelegramActionResult {
+  const topics = ctx.forum?.isReady ? ctx.forum.store.all() : undefined;
+  const hits = searchGroupMemory({
+    query: action.query,
+    limit: action.limit,
+    sessionsDir: ctx.cfg.sessionsDir,
+    store: ctx.store,
+    topics,
+  });
+  return {
+    action: "search_memory",
+    ok: true,
+    data: { query: action.query, hits },
+    userNote:
+      hits.length > 0
+        ? `\u{1F50D} Memory search: ${hits.length} hit(s) for \u201c${action.query.slice(0, 60)}\u201d`
+        : `\u{1F50D} Memory search: no hits for \u201c${action.query.slice(0, 60)}\u201d`,
+  };
+}
+
+async function listBots(ctx: TelegramActionContext): Promise<TelegramActionResult> {
+  if (ctx.cfg.allowedTelegramBots.length === 0) {
+    return {
+      action: "list_bots",
+      ok: true,
+      data: { bots: [], note: "ALLOWED_TELEGRAM_BOTS is empty" },
+      userNote: "\u{1F916} No sibling bots configured (ALLOWED_TELEGRAM_BOTS)",
+    };
+  }
+  const bots = await ctx.bots.listBots(true);
+  const catalog = Object.fromEntries(
+    bots.map((b) => [
+      b.username,
+      b.commands.map((c) =>
+        c.description ? `/${c.command} — ${c.description}` : `/${c.command}`,
+      ),
+    ]),
+  );
+  return {
+    action: "list_bots",
+    ok: true,
+    data: {
+      bots,
+      commands: catalog,
+      usage:
+        "Call bot_command with bot=username (no @), command without leading slash, optional args. " +
+        "Treat replies like MCP tool results. Unknown/timeout commands return ok=false — continue the session; do not treat them as Done.",
+    },
+    userNote: `\u{1F916} Sibling bots: ${bots
+      .map((b) => {
+        const cmds = b.commands.length
+          ? ` (${b.commands.map((c) => "/" + c.command).join(", ")})`
+          : "";
+        return "@" + b.username + cmds;
+      })
+      .join(", ") || "(none)"}`,
+  };
+}
+
+async function botCommand(
+  action: Extract<TelegramAction, { action: "bot_command" }>,
+  ctx: TelegramActionContext,
+): Promise<TelegramActionResult> {
+  // Prefer the configured forum group so sibling bots (group-scoped) see the command.
+  const chatId = ctx.cfg.topicGroupId ?? ctx.chatId;
+  const messageThreadId =
+    ctx.cfg.topicGroupId !== undefined && chatId === ctx.cfg.topicGroupId
+      ? ctx.messageThreadId
+      : undefined;
+
+  const res = await ctx.bots.invokeCommand({
+    bot: action.bot,
+    command: action.command,
+    args: action.args,
+    chatId,
+    messageThreadId,
+  });
+
+  if (!res.ok) {
+    // Timeout / dead bot / bad command: session continues via bridge results.
+    // Never surface as a successful Done.
+    const kind = res.kind;
+    const icon = kind === "timeout" ? "\u23F1\uFE0F" : "\u26A0\uFE0F";
+    return {
+      action: "bot_command",
+      ok: false,
+      error: res.error,
+      data: {
+        bot: action.bot,
+        command: action.command,
+        args: action.args,
+        kind,
+        sessionContinues: true,
+        partialReply: res.partialReply,
+      },
+      userNote: `${icon} Waiting for @${action.bot} /${action.command} failed: ${res.error} (session continues)`,
+    };
+  }
+
+  const partialNote = res.partial
+    ? " \u2014 partial (hard timeout; stream may be incomplete)"
+    : "";
+  return {
+    action: "bot_command",
+    ok: true,
+    data: {
+      bot: action.bot,
+      command: action.command,
+      args: action.args,
+      reply: res.reply,
+      partial: res.partial,
+    },
+    userNote: `\u{1F916} @${action.bot} /${action.command} \u2014 reply ready (${res.reply.length} chars)${partialNote}`,
+  };
+}