talon-agent 1.2.0 → 1.3.0

package/src/frontend/telegram/handlers.ts

@@ -5,11 +5,7 @@
 
 import type { Bot, Context } from "grammy";
 import type { TalonConfig } from "../../util/config.js";
-import {
-  splitMessage,
-  markdownToTelegramHtml,
-  escapeHtml,
-} from "./formatting.js";
+import { markdownToTelegramHtml, escapeHtml } from "./formatting.js";
 import { execute } from "../../core/dispatcher.js";
 import { classify, friendlyMessage } from "../../core/errors.js";
 import {
@@ -391,7 +387,6 @@ const messageQueues = new Map<
     messages: QueuedMessage[];
     timer: ReturnType<typeof setTimeout>;
     bot: Bot;
-    config: TalonConfig;
     numericChatId: number;
     queuedReactionMsgIds: number[];
   }
@@ -446,7 +441,6 @@ function isUserRateLimited(senderId: number): boolean {
  */
 function enqueueMessage(
   bot: Bot,
-  config: TalonConfig,
   chatId: string,
   numericChatId: number,
   msg: QueuedMessage,
@@ -474,7 +468,6 @@ function enqueueMessage(
     messages: [msg],
     timer: setTimeout(() => flushQueue(chatId), DEBOUNCE_MS),
     bot,
-    config,
     numericChatId,
     queuedReactionMsgIds: [] as number[],
   };
@@ -486,7 +479,7 @@ async function flushQueue(chatId: string): Promise<void> {
   if (!entry) return;
   messageQueues.delete(chatId);
 
-  const { messages, bot, config, numericChatId, queuedReactionMsgIds } = entry;
+  const { messages, bot, numericChatId, queuedReactionMsgIds } = entry;
 
   // Clear hourglass reactions on queued messages now that we're processing
   for (const msgId of queuedReactionMsgIds) {
@@ -516,7 +509,6 @@ async function flushQueue(chatId: string): Promise<void> {
   try {
     await processAndReply({
       bot,
-      config,
       chatId,
       numericChatId,
       replyToId: last.replyToId,
@@ -550,7 +542,6 @@ async function flushQueue(chatId: string): Promise<void> {
         await new Promise((r) => setTimeout(r, delayMs));
         await processAndReply({
           bot,
-          config,
           chatId,
           numericChatId,
           replyToId: last.replyToId,
@@ -621,7 +612,6 @@ async function sendHtml(
  */
 type ProcessAndReplyParams = {
   bot: Bot;
-  config: TalonConfig;
   chatId: string | number;
   numericChatId: number;
   replyToId: number;
@@ -692,7 +682,6 @@ function createStreamCallbacks(
 async function processAndReply(params: ProcessAndReplyParams): Promise<void> {
   const {
     bot,
-    config,
     chatId,
     numericChatId,
     replyToId,
@@ -864,7 +853,7 @@ async function handleMediaMessage(
 
     const prompt = promptParts.join("\n");
 
-    enqueueMessage(bot, config, chatId, ctx.chat.id, {
+    enqueueMessage(bot, chatId, ctx.chat.id, {
       prompt,
       replyToId: ctx.message.message_id,
       messageId: ctx.message.message_id,
@@ -920,7 +909,7 @@ export async function handleTextMessage(
   );
   const prompt = fwdCtx + replyCtx + replyPhotoCtx + (ctx.message.text ?? "");
 
-  enqueueMessage(bot, config, chatId, ctx.chat.id, {
+  enqueueMessage(bot, chatId, ctx.chat.id, {
     prompt,
     replyToId: ctx.message.message_id,
     messageId: ctx.message.message_id,
@@ -1040,7 +1029,7 @@ export async function handleStickerMessage(
     .filter(Boolean)
     .join("\n");
 
-  enqueueMessage(bot, config, chatId, ctx.chat.id, {
+  enqueueMessage(bot, chatId, ctx.chat.id, {
     prompt,
     replyToId: ctx.message.message_id,
     messageId: ctx.message.message_id,
@@ -1185,7 +1174,6 @@ export async function handleCallbackQuery(
 
     await processAndReply({
       bot,
-      config,
       chatId,
       numericChatId,
       replyToId,

package/src/plugins/mempalace/index.ts

@@ -0,0 +1,147 @@
+/**
+ * MemPalace plugin — structured long-term memory with vector search.
+ *
+ * Registers the mempalace Python MCP server, giving the agent access to
+ * semantic memory search, knowledge graph operations, and diary entries.
+ *
+ * Configuration in ~/.talon/config.json:
+ *   "mempalace": {
+ *     "enabled": true,
+ *     "palacePath": "/path/to/palace",   // optional, defaults to ~/.talon/workspace/palace/
+ *     "pythonPath": "/path/to/python"     // optional, defaults to mempalace venv python (bin/python on Unix, Scripts/python.exe on Windows)
+ *   }
+ */
+
+import { existsSync, mkdirSync, readFileSync } from "node:fs";
+import { resolve } from "node:path";
+import { execFile as execFileCb, execFileSync } from "node:child_process";
+import { promisify } from "node:util";
+import type { TalonPlugin } from "../../core/plugin.js";
+import { log, logWarn } from "../../util/log.js";
+import { dirs } from "../../util/paths.js";
+
+const execFile = promisify(execFileCb);
+
+/** Load from ~/.talon/prompts/ (user-customisable, seeded on first run) */
+const PROMPT_PATH = resolve(dirs.prompts, "mempalace.md");
+
+/**
+ * Create a mempalace plugin instance with resolved paths.
+ * Uses a factory because MCP server command/args depend on runtime config.
+ */
+export function createMempalacePlugin(config: {
+  pythonPath: string;
+  palacePath: string;
+}): TalonPlugin {
+  const { pythonPath, palacePath } = config;
+
+  return {
+    name: "mempalace",
+    description:
+      "Memory palace — structured long-term memory with vector search",
+    version: "1.0.0",
+
+    mcpServer: {
+      command: pythonPath,
+      args: ["-m", "mempalace.mcp_server", "--palace", palacePath],
+    },
+
+    validateConfig() {
+      const errors: string[] = [];
+      if (!existsSync(pythonPath)) {
+        errors.push(
+          `Python binary not found at ${pythonPath}. Create or select a Python environment, set "pythonPath" to that interpreter, then run: ${pythonPath} -m pip install mempalace`,
+        );
+        return errors;
+      }
+
+      // Verify mempalace.mcp_server is importable (the actual module spawned by MCP)
+      try {
+        execFileSync(pythonPath, ["-c", "import mempalace.mcp_server"], {
+          timeout: 15_000,
+          stdio: "pipe",
+        });
+      } catch (err: unknown) {
+        const execErr =
+          err && typeof err === "object"
+            ? (err as {
+                code?: string;
+                signal?: string;
+                killed?: boolean;
+                stderr?: string | Buffer;
+              })
+            : undefined;
+        const code = execErr?.code;
+        if (code === "ENOENT" || code === "EACCES" || code === "EPERM") {
+          errors.push(
+            `Cannot execute Python at ${pythonPath} (${code}). Check that the path is correct and the binary is executable.`,
+          );
+        } else if (code === "ETIMEDOUT" || execErr?.killed || execErr?.signal) {
+          errors.push(
+            `Python import check timed out or was killed. The interpreter at ${pythonPath} may be unresponsive.`,
+          );
+        } else {
+          const stderr =
+            typeof execErr?.stderr === "string"
+              ? execErr.stderr.trim()
+              : Buffer.isBuffer(execErr?.stderr)
+                ? execErr.stderr.toString("utf-8").trim()
+                : "";
+          errors.push(
+            `mempalace package not installed or mcp_server submodule missing. Run: ${pythonPath} -m pip install mempalace${stderr ? `. Details: ${stderr}` : ""}`,
+          );
+        }
+      }
+
+      return errors.length > 0 ? errors : undefined;
+    },
+
+    async init() {
+      // Ensure palace directory exists
+      if (!existsSync(palacePath)) {
+        mkdirSync(palacePath, { recursive: true });
+        log("mempalace", `Created palace directory: ${palacePath}`);
+      }
+
+      // Quick smoke test — verify mempalace can import and access the palace path
+      try {
+        const { stdout } = await execFile(
+          pythonPath,
+          [
+            "-c",
+            `import mempalace; print(f"mempalace {mempalace.__version__}" if hasattr(mempalace, "__version__") else "mempalace ok")`,
+          ],
+          { timeout: 15_000 },
+        );
+        log("mempalace", stdout.trim() || "Module verified");
+      } catch {
+        // Non-fatal — MCP server handles lazy init
+        log(
+          "mempalace",
+          "Module import check skipped — MCP server will initialize on first use",
+        );
+      }
+
+      log("mempalace", `Ready (palace: ${palacePath})`);
+    },
+
+    getEnvVars() {
+      return {
+        MEMPALACE_PALACE_PATH: palacePath,
+      };
+    },
+
+    getSystemPromptAddition() {
+      try {
+        const template = readFileSync(PROMPT_PATH, "utf-8");
+        return template.replace(/\{\{palacePath\}\}/g, palacePath);
+      } catch (err) {
+        logWarn(
+          "mempalace",
+          `Failed to load prompt from ${PROMPT_PATH}: ${err instanceof Error ? err.message : err}`,
+        );
+        return `## MemPalace — Long-term Memory\n\nPalace location: \`${palacePath}\``;
+      }
+    },
+  };
+}

package/src/util/config.ts

@@ -44,6 +44,17 @@ const configSchema = z.object({
   timezone: z.string().optional(),
   plugins: z.array(pluginEntrySchema).default([]),
 
+  // MemPalace — structured long-term memory with vector search
+  mempalace: z
+    .object({
+      enabled: z.boolean().default(false),
+      /** Palace directory path (default: ~/.talon/workspace/palace/) */
+      palacePath: z.string().min(1).optional(),
+      /** Python binary path (default: ~/.talon/mempalace-venv/bin/python) */
+      pythonPath: z.string().min(1).optional(),
+    })
+    .optional(),
+
   // Display name shown in terminal UI (defaults to "Talon")
   botDisplayName: z.string().default("Talon"),
 

package/src/util/log.ts

@@ -41,7 +41,8 @@ export type LogComponent =
   | "plugin"
   | "teams"
   | "config"
-  | "access";
+  | "access"
+  | "mempalace";
 
 const LOG_FILE = files.log;
 

package/src/util/paths.ts

@@ -51,6 +51,8 @@ export const dirs = {
   prompts: resolve(TALON_ROOT, "prompts"),
   /** Per-chat message traces: ~/.talon/data/traces/ */
   traces: resolve(TALON_ROOT, "data", "traces"),
+  /** MemPalace palace: ~/.talon/workspace/palace/ */
+  palace: resolve(TALON_ROOT, "workspace", "palace"),
 } as const;
 
 // ── Files ──────────────────────────────────────────────────────────────────
@@ -78,6 +80,13 @@ export const files = {
   userSession: resolve(TALON_ROOT, ".user-session"),
   /** PID file for daemon mode: ~/.talon/talon.pid */
   pid: resolve(TALON_ROOT, "talon.pid"),
+  /** MemPalace venv python binary (platform-dependent: bin/python on Unix, Scripts/python.exe on Windows) */
+  mempalacePython: resolve(
+    TALON_ROOT,
+    "mempalace-venv",
+    process.platform === "win32" ? "Scripts" : "bin",
+    process.platform === "win32" ? "python.exe" : "python",
+  ),
   /** Dream mode state: ~/.talon/workspace/memory/dream_state.json */
   dreamState: resolve(TALON_ROOT, "workspace", "memory", "dream_state.json"),
   /** Heartbeat state: ~/.talon/workspace/memory/heartbeat_state.json */