talon-agent 1.0.0 → 1.2.0

package/src/__tests__/workspace-migrate.test.ts

@@ -0,0 +1,256 @@
+/**
+ * Tests for workspace migrateLayout, identity seeding, and prompt seeding.
+ * Uses temp directories and mocks process.cwd() + os.homedir().
+ */
+
+import { describe, it, expect, beforeEach, afterEach, vi } from "vitest";
+import {
+  mkdirSync,
+  writeFileSync,
+  rmSync,
+  existsSync,
+  readFileSync,
+} from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+const TEST_ROOT = join(tmpdir(), `talon-migrate-test-${Date.now()}`);
+const OLD_WORKSPACE = join(TEST_ROOT, "workspace");
+const NEW_ROOT = join(TEST_ROOT, ".talon");
+
+beforeEach(() => {
+  vi.resetModules();
+  if (existsSync(TEST_ROOT)) rmSync(TEST_ROOT, { recursive: true });
+  mkdirSync(TEST_ROOT, { recursive: true });
+
+  vi.doMock("node:os", async (importOriginal) => {
+    const actual = (await importOriginal()) as Record<string, unknown>;
+    return { ...actual, homedir: () => TEST_ROOT };
+  });
+  vi.doMock("../util/log.js", () => ({
+    log: vi.fn(),
+    logError: vi.fn(),
+    logWarn: vi.fn(),
+    logDebug: vi.fn(),
+  }));
+});
+
+afterEach(() => {
+  if (existsSync(TEST_ROOT)) rmSync(TEST_ROOT, { recursive: true });
+});
+
+describe("migrateLayout", () => {
+  it("is a no-op when workspace/ does not exist", async () => {
+    const { migrateLayout } = await import("../util/workspace.js");
+    expect(() => migrateLayout()).not.toThrow();
+    // workspace/sessions.json should NOT have been created since migration never ran
+    expect(existsSync(join(NEW_ROOT, "data", "sessions.json"))).toBe(false);
+  });
+
+  it("is a no-op when .talon/ already exists", async () => {
+    mkdirSync(OLD_WORKSPACE, { recursive: true });
+    mkdirSync(NEW_ROOT, { recursive: true });
+
+    const { migrateLayout } = await import("../util/workspace.js");
+    expect(() => migrateLayout()).not.toThrow();
+    // workspace/ should still exist — migration was skipped
+    expect(existsSync(OLD_WORKSPACE)).toBe(true);
+  });
+
+  it("migrates files from workspace/ to .talon/ layout", async () => {
+    mkdirSync(OLD_WORKSPACE, { recursive: true });
+    writeFileSync(join(OLD_WORKSPACE, "sessions.json"), '{"chat1":{}}');
+    writeFileSync(join(OLD_WORKSPACE, "history.json"), "{}");
+    writeFileSync(join(OLD_WORKSPACE, "talon.json"), '{"frontend":"telegram"}');
+
+    const originalCwd = process.cwd;
+    process.cwd = () => TEST_ROOT;
+
+    try {
+      const { migrateLayout } = await import("../util/workspace.js");
+      migrateLayout();
+
+      const dataDir = join(NEW_ROOT, "data");
+      expect(existsSync(join(dataDir, "sessions.json"))).toBe(true);
+      expect(existsSync(join(dataDir, "history.json"))).toBe(true);
+      expect(existsSync(join(NEW_ROOT, "config.json"))).toBe(true);
+      // Original files should be gone
+      expect(existsSync(join(OLD_WORKSPACE, "sessions.json"))).toBe(false);
+    } finally {
+      process.cwd = originalCwd;
+    }
+  });
+
+  it("migrates directories from workspace/ to .talon/workspace/ layout", async () => {
+    mkdirSync(OLD_WORKSPACE, { recursive: true });
+    const memoryDir = join(OLD_WORKSPACE, "memory");
+    mkdirSync(memoryDir);
+    writeFileSync(join(memoryDir, "notes.md"), "# Memory");
+
+    const originalCwd = process.cwd;
+    process.cwd = () => TEST_ROOT;
+
+    try {
+      const { migrateLayout } = await import("../util/workspace.js");
+      migrateLayout();
+
+      const newMemory = join(NEW_ROOT, "workspace", "memory");
+      expect(existsSync(newMemory)).toBe(true);
+      expect(existsSync(join(newMemory, "notes.md"))).toBe(true);
+    } finally {
+      process.cwd = originalCwd;
+    }
+  });
+
+  it("removes empty workspace/ after migration", async () => {
+    mkdirSync(OLD_WORKSPACE, { recursive: true });
+    // No files — workspace/ is empty
+
+    const originalCwd = process.cwd;
+    process.cwd = () => TEST_ROOT;
+
+    try {
+      const { migrateLayout } = await import("../util/workspace.js");
+      migrateLayout();
+
+      // Empty workspace/ should be removed
+      expect(existsSync(OLD_WORKSPACE)).toBe(false);
+    } finally {
+      process.cwd = originalCwd;
+    }
+  });
+
+  it("falls back to copy+delete when renameSync throws (cross-filesystem simulation)", async () => {
+    mkdirSync(OLD_WORKSPACE, { recursive: true });
+    writeFileSync(join(OLD_WORKSPACE, "sessions.json"), '{"chat1":{}}');
+    const memDir = join(OLD_WORKSPACE, "memory");
+    mkdirSync(memDir);
+    writeFileSync(join(memDir, "notes.md"), "# notes");
+
+    const originalCwd = process.cwd;
+    process.cwd = () => TEST_ROOT;
+
+    // Override renameSync to simulate cross-device link error
+    vi.doMock("node:fs", async (importOriginal) => {
+      const actual = await importOriginal<typeof import("node:fs")>();
+      return {
+        ...actual,
+        renameSync: vi.fn(() => {
+          throw Object.assign(
+            new Error("EXDEV: cross-device link not permitted"),
+            { code: "EXDEV" },
+          );
+        }),
+      };
+    });
+
+    try {
+      const { migrateLayout } = await import("../util/workspace.js");
+      migrateLayout();
+
+      // File was copied via copyFileSync fallback (line 57)
+      expect(existsSync(join(NEW_ROOT, "data", "sessions.json"))).toBe(true);
+      // Directory was copied via cpSync fallback (line 81)
+      expect(
+        existsSync(join(NEW_ROOT, "workspace", "memory", "notes.md")),
+      ).toBe(true);
+    } finally {
+      process.cwd = originalCwd;
+    }
+  });
+
+  it("leaves workspace/ when non-migration files remain after migration", async () => {
+    mkdirSync(OLD_WORKSPACE, { recursive: true });
+    // A file that is NOT in the migration list
+    writeFileSync(join(OLD_WORKSPACE, "unknown-extra-file.txt"), "extra");
+
+    const originalCwd = process.cwd;
+    process.cwd = () => TEST_ROOT;
+
+    try {
+      const { migrateLayout } = await import("../util/workspace.js");
+      migrateLayout();
+
+      // workspace/ should still exist since it's not empty
+      expect(existsSync(OLD_WORKSPACE)).toBe(true);
+      expect(existsSync(join(OLD_WORKSPACE, "unknown-extra-file.txt"))).toBe(
+        true,
+      );
+    } finally {
+      process.cwd = originalCwd;
+    }
+  });
+});
+
+describe("initWorkspace — identity and prompt seeding", () => {
+  it("creates identity.md when it does not exist", async () => {
+    const originalCwd = process.cwd;
+    process.cwd = () => TEST_ROOT;
+
+    try {
+      const { initWorkspace } = await import("../util/workspace.js");
+      initWorkspace(join(TEST_ROOT, "ws"));
+
+      // identity.md is at ~/.talon/workspace/identity.md
+      const identityFile = join(NEW_ROOT, "workspace", "identity.md");
+      expect(existsSync(identityFile)).toBe(true);
+      const content = readFileSync(identityFile, "utf-8");
+      expect(content).toContain("Identity");
+    } finally {
+      process.cwd = originalCwd;
+    }
+  });
+
+  it("seeds .md prompt files from prompts/ directory", async () => {
+    // prompts/ is resolved relative to process.cwd()
+    const promptsDir = join(TEST_ROOT, "prompts");
+    mkdirSync(promptsDir, { recursive: true });
+    writeFileSync(join(promptsDir, "system.md"), "# System Prompt");
+    writeFileSync(join(promptsDir, "dream.md"), "# Dream Prompt");
+    writeFileSync(join(promptsDir, "not-a-prompt.txt"), "ignored");
+
+    const originalCwd = process.cwd;
+    process.cwd = () => TEST_ROOT;
+
+    try {
+      const { initWorkspace } = await import("../util/workspace.js");
+      initWorkspace(join(TEST_ROOT, "ws"));
+
+      // prompts are seeded to ~/.talon/prompts/
+      const talonPromptsDir = join(NEW_ROOT, "prompts");
+      expect(existsSync(join(talonPromptsDir, "system.md"))).toBe(true);
+      expect(existsSync(join(talonPromptsDir, "dream.md"))).toBe(true);
+      // .txt file should NOT be copied
+      expect(existsSync(join(talonPromptsDir, "not-a-prompt.txt"))).toBe(false);
+    } finally {
+      process.cwd = originalCwd;
+    }
+  });
+
+  it("does not overwrite existing prompt files", async () => {
+    const promptsDir = join(TEST_ROOT, "prompts");
+    mkdirSync(promptsDir, { recursive: true });
+    writeFileSync(join(promptsDir, "custom.md"), "# Package version");
+
+    const talonPromptsDir = join(NEW_ROOT, "prompts");
+    mkdirSync(talonPromptsDir, { recursive: true });
+    writeFileSync(
+      join(talonPromptsDir, "custom.md"),
+      "# User customized version",
+    );
+
+    const originalCwd = process.cwd;
+    process.cwd = () => TEST_ROOT;
+
+    try {
+      const { initWorkspace } = await import("../util/workspace.js");
+      initWorkspace(join(TEST_ROOT, "ws"));
+
+      // User version should be preserved
+      const content = readFileSync(join(talonPromptsDir, "custom.md"), "utf-8");
+      expect(content).toBe("# User customized version");
+    } finally {
+      process.cwd = originalCwd;
+    }
+  });
+});

package/src/__tests__/workspace.test.ts

@@ -1,5 +1,13 @@
 import { describe, it, expect, beforeEach, afterEach, vi } from "vitest";
-import { mkdirSync, writeFileSync, rmSync, existsSync, readdirSync } from "node:fs";
+import {
+  mkdirSync,
+  writeFileSync,
+  rmSync,
+  existsSync,
+  readdirSync,
+  readFileSync,
+  symlinkSync,
+} from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
 
@@ -17,6 +25,7 @@ import {
   cleanupUploads,
   startUploadCleanup,
   stopUploadCleanup,
+  migrateLayout,
 } from "../util/workspace.js";
 
 const TEST_ROOT = join(tmpdir(), `talon-ws-test-${Date.now()}`);
@@ -182,3 +191,56 @@ describe("startUploadCleanup / stopUploadCleanup", () => {
     expect(() => stopUploadCleanup()).not.toThrow();
   });
 });
+
+describe("migrateLayout", () => {
+  it("is a no-op when workspace/ directory does not exist", () => {
+    // No workspace/ dir → should not throw or create anything
+    expect(() => migrateLayout()).not.toThrow();
+  });
+
+  it("is a no-op when .talon/ already exists", () => {
+    // Even if workspace/ exists, skip migration if .talon/ already there
+    expect(() => migrateLayout()).not.toThrow();
+  });
+});
+
+describe("getWorkspaceDiskUsage — edge cases", () => {
+  it("returns 0 for non-existent directory", () => {
+    expect(getWorkspaceDiskUsage("/non/existent/path/xyz123")).toBe(0);
+  });
+
+  it("counts multiple files correctly", () => {
+    mkdirSync(TEST_ROOT, { recursive: true });
+    writeFileSync(join(TEST_ROOT, "a.txt"), "12345"); // 5 bytes
+    writeFileSync(join(TEST_ROOT, "b.txt"), "123"); // 3 bytes
+    const usage = getWorkspaceDiskUsage(TEST_ROOT);
+    expect(usage).toBe(8);
+  });
+
+  it("skips symlinks — entry.isFile() FALSE branch (L147)", () => {
+    mkdirSync(TEST_ROOT, { recursive: true });
+    writeFileSync(join(TEST_ROOT, "real.txt"), "hello"); // 5 bytes
+    // symlink: isDirectory()=false, isFile()=false → skipped by walk
+    symlinkSync(join(TEST_ROOT, "real.txt"), join(TEST_ROOT, "link.txt"));
+    const usage = getWorkspaceDiskUsage(TEST_ROOT);
+    // Only real.txt counts (5 bytes); symlink is not counted
+    expect(usage).toBe(5);
+  });
+});
+
+describe("startUploadCleanup — setInterval callback (function coverage)", () => {
+  it("fires periodic cleanup via setInterval arrow function", () => {
+    vi.useFakeTimers();
+    mkdirSync(TEST_ROOT, { recursive: true });
+    mkdirSync(join(TEST_ROOT, "uploads"), { recursive: true });
+    writeFileSync(join(TEST_ROOT, "uploads", "file.jpg"), "data");
+
+    startUploadCleanup(TEST_ROOT);
+    // Advance past CLEANUP_INTERVAL_MS (1 hour) to fire the setInterval callback
+    vi.advanceTimersByTime(60 * 60 * 1000 + 1);
+    stopUploadCleanup();
+
+    vi.useRealTimers();
+    // Just verify no error was thrown — the arrow function was exercised
+  });
+});

package/src/backend/claude-sdk/tools.ts

@@ -113,7 +113,10 @@ Examples:
     first_name: z.string().optional().describe("Contact first name"),
     last_name: z.string().optional().describe("Contact last name"),
     title: z.string().optional().describe("Audio title (for type=audio)"),
-    performer: z.string().optional().describe("Audio performer/artist (for type=audio)"),
+    performer: z
+      .string()
+      .optional()
+      .describe("Audio performer/artist (for type=audio)"),
     emoji: z.string().optional().describe("Dice emoji (🎲🎯🏀⚽🎳🎰)"),
     delay_seconds: z
       .number()
@@ -370,7 +373,9 @@ server.tool(
   "download_media",
   "Download a photo, document, or other media from a message by its ID. Saves the file to the workspace and returns the file path so you can read/analyze it. Use this when you see a [photo] or [document] in chat history but don't have the file.",
   {
-    message_id: z.number().describe("Message ID containing the media to download"),
+    message_id: z
+      .number()
+      .describe("Message ID containing the media to download"),
   },
   async (params) => textResult(await callBridge("download_media", params)),
 );
@@ -379,7 +384,11 @@ server.tool(
   "get_sticker_pack",
   "Get all stickers in a sticker pack by its name. Returns emoji + file_id for each sticker so you can send them. Use when you see a sticker set name in chat history.",
   {
-    set_name: z.string().describe("Sticker set name (e.g. 'AnimatedEmojies' or from sticker metadata)"),
+    set_name: z
+      .string()
+      .describe(
+        "Sticker set name (e.g. 'AnimatedEmojies' or from sticker metadata)",
+      ),
   },
   async (params) => textResult(await callBridge("get_sticker_pack", params)),
 );
@@ -388,7 +397,9 @@ server.tool(
   "download_sticker",
   "Download a sticker image to workspace so you can view its contents. Returns the file path.",
   {
-    file_id: z.string().describe("Sticker file_id from chat history or sticker pack listing"),
+    file_id: z
+      .string()
+      .describe("Sticker file_id from chat history or sticker pack listing"),
   },
   async (params) => textResult(await callBridge("download_sticker", params)),
 );
@@ -437,10 +448,19 @@ Type "message" sends the content as a text message.
 Type "query" runs the content as a Claude prompt with full tool access (can search, create files, send messages, etc).`,
   {
     name: z.string().describe("Human-readable name for the job"),
-    schedule: z.string().describe("Cron expression (5-field: minute hour day month weekday)"),
-    type: z.enum(["message", "query"]).describe("Job type: 'message' sends text, 'query' runs a Claude prompt"),
+    schedule: z
+      .string()
+      .describe("Cron expression (5-field: minute hour day month weekday)"),
+    type: z
+      .enum(["message", "query"])
+      .describe("Job type: 'message' sends text, 'query' runs a Claude prompt"),
     content: z.string().describe("Message text or query prompt"),
-    timezone: z.string().optional().describe("IANA timezone (e.g. 'America/New_York'). Defaults to system timezone."),
+    timezone: z
+      .string()
+      .optional()
+      .describe(
+        "IANA timezone (e.g. 'America/New_York'). Defaults to system timezone.",
+      ),
   },
   async (params) => textResult(await callBridge("create_cron_job", params)),
 );
@@ -496,11 +516,23 @@ The set name will automatically get "_by_<botname>" appended if needed.
 Example: create_sticker_set(user_id=123, name="cool_pack", title="Cool Stickers", file_path="/path/to/sticker.png", emoji_list=["😎"])`,
   {
     user_id: z.number().describe("Telegram user ID who will own the pack"),
-    name: z.string().describe("Short name for the pack (a-z, 0-9, underscores). Will get _by_<botname> appended."),
+    name: z
+      .string()
+      .describe(
+        "Short name for the pack (a-z, 0-9, underscores). Will get _by_<botname> appended.",
+      ),
     title: z.string().describe("Display title for the pack (1-64 chars)"),
-    file_path: z.string().describe("Path to the sticker image file (PNG/WEBP, 512x512 max)"),
-    emoji_list: z.array(z.string()).optional().describe("Emojis for this sticker (default: ['🎨'])"),
-    format: z.enum(["static", "animated", "video"]).optional().describe("Sticker format (default: static)"),
+    file_path: z
+      .string()
+      .describe("Path to the sticker image file (PNG/WEBP, 512x512 max)"),
+    emoji_list: z
+      .array(z.string())
+      .optional()
+      .describe("Emojis for this sticker (default: ['🎨'])"),
+    format: z
+      .enum(["static", "animated", "video"])
+      .optional()
+      .describe("Sticker format (default: static)"),
   },
   async (params) => textResult(await callBridge("create_sticker_set", params)),
 );
@@ -512,8 +544,14 @@ server.tool(
     user_id: z.number().describe("Telegram user ID who owns the pack"),
     name: z.string().describe("Sticker set name (including _by_<botname>)"),
     file_path: z.string().describe("Path to the sticker image file"),
-    emoji_list: z.array(z.string()).optional().describe("Emojis for this sticker (default: ['🎨'])"),
-    format: z.enum(["static", "animated", "video"]).optional().describe("Sticker format (default: static)"),
+    emoji_list: z
+      .array(z.string())
+      .optional()
+      .describe("Emojis for this sticker (default: ['🎨'])"),
+    format: z
+      .enum(["static", "animated", "video"])
+      .optional()
+      .describe("Sticker format (default: static)"),
   },
   async (params) => textResult(await callBridge("add_sticker_to_set", params)),
 );
@@ -522,9 +560,12 @@ server.tool(
   "delete_sticker_from_set",
   "Remove a specific sticker from a pack by its file_id.",
   {
-    sticker_file_id: z.string().describe("file_id of the sticker to remove (get from get_sticker_pack)"),
+    sticker_file_id: z
+      .string()
+      .describe("file_id of the sticker to remove (get from get_sticker_pack)"),
   },
-  async (params) => textResult(await callBridge("delete_sticker_from_set", params)),
+  async (params) =>
+    textResult(await callBridge("delete_sticker_from_set", params)),
 );
 
 server.tool(
@@ -534,7 +575,8 @@ server.tool(
     name: z.string().describe("Sticker set name"),
     title: z.string().describe("New title (1-64 chars)"),
   },
-  async (params) => textResult(await callBridge("set_sticker_set_title", params)),
+  async (params) =>
+    textResult(await callBridge("set_sticker_set_title", params)),
 );
 
 server.tool(
@@ -566,9 +608,13 @@ server.tool(
   "list_media",
   "List recent photos, documents, and other media in the current chat with file paths. Use this to find a previously sent photo or file to re-read or reference.",
   {
-    limit: z.number().optional().describe("Number of entries (default 10, max 20)"),
+    limit: z
+      .number()
+      .optional()
+      .describe("Number of entries (default 10, max 20)"),
   },
-  async (params) => textResult(await callBridge("list_media", { limit: params.limit })),
+  async (params) =>
+    textResult(await callBridge("list_media", { limit: params.limit })),
 );
 
 // ── Web ─────────────────────────────────────────────────────────────────────

package/src/bootstrap.ts

@@ -21,6 +21,7 @@ import { initDispatcher } from "./core/dispatcher.js";
 import { initPulse, resetPulseTimer } from "./core/pulse.js";
 import { initCron } from "./core/cron.js";
 import { initDream } from "./core/dream.js";
+import { initHeartbeat } from "./core/heartbeat.js";
 import { log } from "./util/log.js";
 import type { TalonConfig } from "./util/config.js";
 import type { QueryBackend, ContextManager } from "./core/types.js";
@@ -63,14 +64,11 @@ export async function bootstrap(
 
   // Load plugins (external tool packages)
   if (config.plugins.length > 0) {
-    const { loadPlugins, getPluginPromptAdditions } = await import(
-      "./core/plugin.js"
-    );
+    const { loadPlugins, getPluginPromptAdditions } =
+      await import("./core/plugin.js");
     const frontends =
       options.frontendNames ??
-      (Array.isArray(config.frontend)
-        ? config.frontend
-        : [config.frontend]);
+      (Array.isArray(config.frontend) ? config.frontend : [config.frontend]);
     await loadPlugins(config.plugins, frontends);
     rebuildSystemPrompt(config, getPluginPromptAdditions());
   }
@@ -99,18 +97,14 @@ export async function initBackendAndDispatcher(
   let backend: QueryBackend;
 
   if (config.backend === "opencode") {
-    const {
-      initOpenCodeAgent,
-      handleMessage: opencodeHandleMessage,
-    } = await import("./backend/opencode/index.js");
+    const { initOpenCodeAgent, handleMessage: opencodeHandleMessage } =
+      await import("./backend/opencode/index.js");
     initOpenCodeAgent(config, frontend.getBridgePort);
     backend = { query: (params) => opencodeHandleMessage(params) };
     log("bot", "Backend: OpenCode");
   } else {
-    const {
-      initAgent: initClaudeAgent,
-      handleMessage: claudeHandleMessage,
-    } = await import("./backend/claude-sdk/index.js");
+    const { initAgent: initClaudeAgent, handleMessage: claudeHandleMessage } =
+      await import("./backend/claude-sdk/index.js");
     initClaudeAgent(config, frontend.getBridgePort);
     backend = { query: (params) => claudeHandleMessage(params) };
     log("bot", "Backend: Claude SDK");
@@ -131,4 +125,10 @@ export async function initBackendAndDispatcher(
     claudeBinary: config.claudeBinary,
     workspace: config.workspace,
   });
+  initHeartbeat({
+    model: config.model,
+    heartbeatModel: config.heartbeatModel,
+    claudeBinary: config.claudeBinary,
+    workspace: config.workspace,
+  });
 }