@aaroncql/pim-agent 0.0.1 → 0.2.0

package/src/telegram/SessionRegistry.test.ts

@@ -1,89 +0,0 @@
-import type { Api } from "grammy";
-import { mkdtemp, rm } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { afterEach, beforeEach, describe, expect, test } from "bun:test";
-
-import { Fs } from "../shared/Fs";
-import { type TelegramConfig } from "./Config";
-import { SessionRegistry } from "./SessionRegistry";
-import type { SessionSettings } from "./Session";
-import { TaskScheduler } from "./TaskScheduler";
-
-let tmp: string;
-let config: TelegramConfig;
-const stubApi = {} as Api;
-const stubScheduler = new TaskScheduler({
-  configDir: "/tmp",
-  runTask: async () => {},
-});
-
-beforeEach(async () => {
-  tmp = await mkdtemp(join(tmpdir(), "pim-session-registry-test-"));
-  config = {
-    token: "token",
-    allow: [],
-    cwd: tmp,
-    configDir: tmp,
-  };
-});
-
-afterEach(async () => {
-  await rm(tmp, { recursive: true, force: true });
-});
-
-async function readState(): Promise<Record<string, SessionSettings>> {
-  return Fs.readJsonOrEmpty<Record<string, SessionSettings>>(
-    join(tmp, "state.json"),
-    {}
-  );
-}
-
-async function writeState(
-  state: Record<string, SessionSettings>
-): Promise<void> {
-  await Fs.writeAtomic(join(tmp, "state.json"), JSON.stringify(state, null, 2));
-}
-
-describe("SessionRegistry state", () => {
-  test("loads persisted state and preserves it when mutating another session", async () => {
-    await writeState({
-      "1-main": {
-        cwd: "/repo",
-        cumulativeCost: 12.5,
-        sessionPath: "/sessions/one.jsonl",
-      },
-    });
-
-    const registry = new SessionRegistry(config, stubApi, stubScheduler);
-    await registry.init();
-    const session = registry.get({ chatId: 2, threadId: undefined });
-    await session.setThinkingLevel("off");
-
-    const loaded = await readState();
-    expect(loaded["1-main"]).toEqual({
-      cwd: "/repo",
-      cumulativeCost: 12.5,
-      sessionPath: "/sessions/one.jsonl",
-    });
-    expect(loaded["2-main"]?.thinkingLevel).toBe("off");
-  });
-
-  test("does not flush state when disposed before init", async () => {
-    await writeState({
-      "1-main": {
-        cwd: "/repo",
-        cumulativeCost: 12.5,
-      },
-    });
-
-    const registry = new SessionRegistry(config, stubApi, stubScheduler);
-    await registry.disposeAll();
-
-    const loaded = await readState();
-    expect(loaded["1-main"]).toEqual({
-      cwd: "/repo",
-      cumulativeCost: 12.5,
-    });
-  });
-});

package/src/telegram/TaskScheduler.test.ts

@@ -1,278 +0,0 @@
-import { mkdtemp, readdir, rm } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { afterEach, beforeEach, describe, expect, test } from "bun:test";
-
-import type { SessionId } from "./Session";
-import { TaskScheduler } from "./TaskScheduler";
-import type { ScheduledTask } from "./TaskSchema";
-import { TaskStore } from "./TaskStore";
-
-let tmp: string;
-const sessionId: SessionId = { chatId: 42, threadId: undefined };
-
-beforeEach(async () => {
-  tmp = await mkdtemp(join(tmpdir(), "pim-scheduler-test-"));
-});
-
-afterEach(async () => {
-  await rm(tmp, { recursive: true, force: true });
-});
-
-function makeScheduler(opts: {
-  readonly now: () => number;
-  readonly onFire?: (task: ScheduledTask) => Promise<void>;
-}): { readonly scheduler: TaskScheduler; readonly fired: ScheduledTask[] } {
-  const fired: ScheduledTask[] = [];
-  const scheduler = new TaskScheduler({
-    configDir: tmp,
-    runTask: async (task) => {
-      fired.push(task);
-      await opts.onFire?.(task);
-    },
-    now: opts.now,
-  });
-  return { scheduler, fired };
-}
-
-async function listTaskFiles(): Promise<string[]> {
-  try {
-    return await readdir(join(tmp, "tasks"));
-  } catch {
-    return [];
-  }
-}
-
-describe("TaskScheduler.parseDuration", () => {
-  test("parses simple units", () => {
-    expect(TaskScheduler.parseDuration("30s")).toBe(30_000);
-    expect(TaskScheduler.parseDuration("5m")).toBe(300_000);
-    expect(TaskScheduler.parseDuration("2h")).toBe(7_200_000);
-    expect(TaskScheduler.parseDuration("1d")).toBe(86_400_000);
-  });
-
-  test("parses compound durations", () => {
-    expect(TaskScheduler.parseDuration("1h30m")).toBe(5_400_000);
-    expect(TaskScheduler.parseDuration("2h15m30s")).toBe(8_130_000);
-  });
-
-  test("rejects garbage", () => {
-    expect(() => TaskScheduler.parseDuration("")).toThrow();
-    expect(() => TaskScheduler.parseDuration("forever")).toThrow();
-    expect(() => TaskScheduler.parseDuration("10")).toThrow();
-  });
-});
-
-describe("TaskScheduler.tick", () => {
-  test("fires due active task and reschedules interval", async () => {
-    const t0 = Date.parse("2026-05-14T12:00:00Z");
-    const { scheduler, fired } = makeScheduler({ now: () => t0 });
-    const task = await scheduler.create(sessionId, {
-      prompt: "test",
-      schedule: { type: "interval", every: "30m" },
-    });
-    expect(task.nextRun).toBe(new Date(t0 + 30 * 60_000).toISOString());
-
-    // Not yet due
-    await scheduler.tick();
-    expect(fired).toHaveLength(0);
-
-    // 30 min later, due
-    const t1 = t0 + 30 * 60_000 + 5_000;
-    const later = makeScheduler({ now: () => t1 });
-    await later.scheduler.tick();
-    expect(later.fired).toHaveLength(1);
-    expect(later.fired[0]!.id).toBe(task.id);
-
-    const reloaded = (await TaskStore.loadAll(tmp))[0]!;
-    expect(reloaded.nextRun).toBe(new Date(t1 + 30 * 60_000).toISOString());
-  });
-
-  test("skips paused tasks", async () => {
-    const t0 = Date.parse("2026-05-14T12:00:00Z");
-    const { scheduler } = makeScheduler({ now: () => t0 });
-    const task = await scheduler.create(sessionId, {
-      prompt: "test",
-      schedule: { type: "interval", every: "5m" },
-    });
-    await scheduler.setStatus(sessionId, task.id, "paused");
-
-    const t1 = t0 + 6 * 60_000;
-    const { scheduler: s2, fired } = makeScheduler({ now: () => t1 });
-    await s2.tick();
-    expect(fired).toHaveLength(0);
-
-    // File still exists
-    expect(await listTaskFiles()).toHaveLength(1);
-  });
-
-  test("once task is deleted after firing", async () => {
-    const t0 = Date.parse("2026-05-14T12:00:00Z");
-    const { scheduler } = makeScheduler({ now: () => t0 });
-    const at = new Date(t0 + 60_000).toISOString();
-    await scheduler.create(sessionId, {
-      prompt: "test",
-      schedule: { type: "once", at },
-    });
-
-    const t1 = t0 + 90_000;
-    const { scheduler: s2, fired } = makeScheduler({ now: () => t1 });
-    await s2.tick();
-    expect(fired).toHaveLength(1);
-    expect(await listTaskFiles()).toHaveLength(0);
-  });
-
-  test("missed >24h is advanced silently without firing", async () => {
-    const t0 = Date.parse("2026-05-14T12:00:00Z");
-    // Manually write a task whose nextRun is 26h in the past
-    const stale: ScheduledTask = {
-      id: "stale-task",
-      prompt: "test",
-      chatId: sessionId.chatId,
-      threadId: sessionId.threadId,
-      schedule: { type: "interval", every: "1h" },
-      status: "active",
-      nextRun: new Date(t0 - 26 * 3600_000).toISOString(),
-      expires: null,
-      isolatedSession: false,
-      createdAt: new Date(t0 - 30 * 3600_000).toISOString(),
-    };
-    await TaskStore.save(tmp, stale);
-
-    const { scheduler, fired } = makeScheduler({ now: () => t0 });
-    await scheduler.tick();
-    expect(fired).toHaveLength(0);
-
-    const reloaded = (await TaskStore.loadAll(tmp))[0]!;
-    expect(Date.parse(reloaded.nextRun)).toBeGreaterThan(t0);
-  });
-
-  test("missed <24h fires once", async () => {
-    const t0 = Date.parse("2026-05-14T12:00:00Z");
-    const stale: ScheduledTask = {
-      id: "recent-miss",
-      prompt: "test",
-      chatId: sessionId.chatId,
-      threadId: sessionId.threadId,
-      schedule: { type: "interval", every: "1h" },
-      status: "active",
-      nextRun: new Date(t0 - 2 * 3600_000).toISOString(),
-      expires: null,
-      isolatedSession: false,
-      createdAt: new Date(t0 - 5 * 3600_000).toISOString(),
-    };
-    await TaskStore.save(tmp, stale);
-
-    const { scheduler, fired } = makeScheduler({ now: () => t0 });
-    await scheduler.tick();
-    expect(fired).toHaveLength(1);
-  });
-
-  test("expired task is deleted without firing", async () => {
-    const t0 = Date.parse("2026-05-14T12:00:00Z");
-    const expired: ScheduledTask = {
-      id: "expired",
-      prompt: "test",
-      chatId: sessionId.chatId,
-      threadId: sessionId.threadId,
-      schedule: { type: "interval", every: "1h" },
-      status: "active",
-      nextRun: new Date(t0 - 60_000).toISOString(),
-      expires: new Date(t0 - 30_000).toISOString(),
-      isolatedSession: false,
-      createdAt: new Date(t0 - 2 * 3600_000).toISOString(),
-    };
-    await TaskStore.save(tmp, expired);
-
-    const { scheduler, fired } = makeScheduler({ now: () => t0 });
-    await scheduler.tick();
-    expect(fired).toHaveLength(0);
-    expect(await listTaskFiles()).toHaveLength(0);
-  });
-
-  test("cron task next-run advances via Bun.cron.parse", async () => {
-    const t0 = Date.parse("2026-05-14T12:00:00Z");
-    const { scheduler } = makeScheduler({ now: () => t0 });
-    const task = await scheduler.create(sessionId, {
-      prompt: "test",
-      schedule: { type: "cron", expr: "0 * * * *" },
-    });
-    expect(task.nextRun).toBe(new Date(t0 + 3600_000).toISOString());
-
-    // Fire it
-    const fireTime = t0 + 3600_000 + 30_000;
-    const { scheduler: s2, fired } = makeScheduler({ now: () => fireTime });
-    await s2.tick();
-    expect(fired).toHaveLength(1);
-
-    const reloaded = (await TaskStore.loadAll(tmp))[0]!;
-    // Should advance to next top-of-hour after firing
-    expect(Date.parse(reloaded.nextRun)).toBeGreaterThan(fireTime);
-  });
-});
-
-describe("TaskScheduler.create validation", () => {
-  test("rejects 'once' with past timestamp", async () => {
-    const t0 = Date.parse("2026-05-14T12:00:00Z");
-    const { scheduler } = makeScheduler({ now: () => t0 });
-    await expect(
-      scheduler.create(sessionId, {
-        prompt: "test",
-        schedule: { type: "once", at: new Date(t0 - 1000).toISOString() },
-      })
-    ).rejects.toThrow();
-  });
-
-  test("rejects sub-minute interval", async () => {
-    const t0 = Date.parse("2026-05-14T12:00:00Z");
-    const { scheduler } = makeScheduler({ now: () => t0 });
-    await expect(
-      scheduler.create(sessionId, {
-        prompt: "test",
-        schedule: { type: "interval", every: "30s" },
-      })
-    ).rejects.toThrow();
-  });
-
-  test("rejects expires before first nextRun", async () => {
-    const t0 = Date.parse("2026-05-14T12:00:00Z");
-    const { scheduler } = makeScheduler({ now: () => t0 });
-    await expect(
-      scheduler.create(sessionId, {
-        prompt: "test",
-        schedule: { type: "interval", every: "1h" },
-        expires: new Date(t0 + 5 * 60_000).toISOString(),
-      })
-    ).rejects.toThrow();
-  });
-});
-
-describe("TaskScheduler.list", () => {
-  test("filters by chat/thread", async () => {
-    const t0 = Date.parse("2026-05-14T12:00:00Z");
-    const { scheduler } = makeScheduler({ now: () => t0 });
-    await scheduler.create(
-      { chatId: 1, threadId: undefined },
-      { prompt: "a", schedule: { type: "interval", every: "1h" } }
-    );
-    await scheduler.create(
-      { chatId: 1, threadId: 99 },
-      { prompt: "b", schedule: { type: "interval", every: "1h" } }
-    );
-    await scheduler.create(
-      { chatId: 2, threadId: undefined },
-      { prompt: "c", schedule: { type: "interval", every: "1h" } }
-    );
-
-    const main = await scheduler.list({
-      chatId: 1,
-      threadId: undefined,
-    });
-    expect(main).toHaveLength(1);
-    expect(main[0]!.prompt).toBe("a");
-
-    const threaded = await scheduler.list({ chatId: 1, threadId: 99 });
-    expect(threaded).toHaveLength(1);
-    expect(threaded[0]!.prompt).toBe("b");
-  });
-});

package/src/telegram/TaskTool.test.ts

@@ -1,179 +0,0 @@
-import { mkdtemp, rm } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { afterEach, beforeEach, describe, expect, test } from "bun:test";
-
-import type { SessionId } from "./Session";
-import { TaskScheduler } from "./TaskScheduler";
-import { TaskTool } from "./TaskTool";
-import type { ScheduledTask, TaskToolInput } from "./TaskSchema";
-
-let tmp: string;
-const sessionId: SessionId = { chatId: 7, threadId: undefined };
-const otherSessionId: SessionId = { chatId: 7, threadId: 99 };
-
-beforeEach(async () => {
-  tmp = await mkdtemp(join(tmpdir(), "pim-task-tool-test-"));
-});
-
-afterEach(async () => {
-  await rm(tmp, { recursive: true, force: true });
-});
-
-function makeTool(opts?: { readonly now?: () => number }): {
-  readonly run: (
-    input: TaskToolInput
-  ) => Promise<{ readonly text: string; readonly details: unknown }>;
-  readonly scheduler: TaskScheduler;
-} {
-  const scheduler = new TaskScheduler({
-    configDir: tmp,
-    runTask: async () => {},
-    now: opts?.now ?? ((): number => Date.now()),
-  });
-  const tool = TaskTool.build({ scheduler, sessionId });
-  const run = async (
-    input: TaskToolInput
-  ): Promise<{ readonly text: string; readonly details: unknown }> => {
-    const result = await tool.execute(
-      "test-call-id",
-      input,
-      new AbortController().signal,
-      undefined,
-      // ExtensionContext stub — tool doesn't use it
-      {} as never
-    );
-    return {
-      text: result.content
-        .filter((c): c is { type: "text"; text: string } => c.type === "text")
-        .map((c) => c.text)
-        .join("\n"),
-      details: result.details,
-    };
-  };
-  return { run, scheduler };
-}
-
-describe("task tool: create", () => {
-  test("creates an interval task and returns id + nextRun", async () => {
-    const t0 = Date.parse("2026-05-14T12:00:00Z");
-    const { run } = makeTool({ now: () => t0 });
-    const result = await run({
-      action: "create",
-      prompt: "drink water",
-      schedule: { type: "interval", every: "1h" },
-    });
-    expect(result.text).toMatch(/^Created task /);
-    const details = result.details as ScheduledTask;
-    expect(details.prompt).toBe("drink water");
-    expect(details.nextRun).toBe(new Date(t0 + 3600_000).toISOString());
-  });
-
-  test("rejects sub-minute interval", async () => {
-    const { run } = makeTool();
-    await expect(
-      run({
-        action: "create",
-        prompt: "spam",
-        schedule: { type: "interval", every: "10s" },
-      })
-    ).rejects.toThrow(/at least 1 minute/);
-  });
-
-  test("rejects invalid cron", async () => {
-    const { run } = makeTool();
-    await expect(
-      run({
-        action: "create",
-        prompt: "test",
-        schedule: { type: "cron", expr: "not a cron" },
-      })
-    ).rejects.toThrow();
-  });
-
-  test("requires prompt and schedule", async () => {
-    const { run } = makeTool();
-    await expect(run({ action: "create" })).rejects.toThrow(/prompt/);
-    await expect(run({ action: "create", prompt: "hi" })).rejects.toThrow(
-      /schedule/
-    );
-  });
-});
-
-describe("task tool: list/delete/pause/resume", () => {
-  test("list filters to current sessionId", async () => {
-    const t0 = Date.parse("2026-05-14T12:00:00Z");
-    const { run, scheduler } = makeTool({ now: () => t0 });
-    await run({
-      action: "create",
-      prompt: "mine",
-      schedule: { type: "interval", every: "1h" },
-    });
-    await scheduler.create(otherSessionId, {
-      prompt: "not mine",
-      schedule: { type: "interval", every: "1h" },
-    });
-    const result = await run({ action: "list" });
-    const details = result.details as { readonly tasks: ScheduledTask[] };
-    expect(details.tasks).toHaveLength(1);
-    expect(details.tasks[0]!.prompt).toBe("mine");
-  });
-
-  test("delete removes by id", async () => {
-    const t0 = Date.parse("2026-05-14T12:00:00Z");
-    const { run } = makeTool({ now: () => t0 });
-    const created = await run({
-      action: "create",
-      prompt: "soon-gone",
-      schedule: { type: "interval", every: "1h" },
-    });
-    const id = (created.details as ScheduledTask).id;
-    await run({ action: "delete", id });
-    const list = await run({ action: "list" });
-    expect((list.details as { tasks: ScheduledTask[] }).tasks).toHaveLength(0);
-  });
-
-  test("delete refuses cross-session id", async () => {
-    const t0 = Date.parse("2026-05-14T12:00:00Z");
-    const { run, scheduler } = makeTool({ now: () => t0 });
-    const foreign = await scheduler.create(otherSessionId, {
-      prompt: "not yours",
-      schedule: { type: "interval", every: "1h" },
-    });
-    await expect(run({ action: "delete", id: foreign.id })).rejects.toThrow(
-      /no task/
-    );
-  });
-
-  test("pause flips status; resume undoes it", async () => {
-    const t0 = Date.parse("2026-05-14T12:00:00Z");
-    const { run } = makeTool({ now: () => t0 });
-    const created = await run({
-      action: "create",
-      prompt: "p",
-      schedule: { type: "interval", every: "1h" },
-    });
-    const id = (created.details as ScheduledTask).id;
-
-    const paused = await run({ action: "pause", id });
-    expect((paused.details as ScheduledTask).status).toBe("paused");
-
-    const resumed = await run({ action: "resume", id });
-    expect((resumed.details as ScheduledTask).status).toBe("active");
-  });
-});
-
-describe("task tool: update_prompt", () => {
-  test("changes prompt text", async () => {
-    const t0 = Date.parse("2026-05-14T12:00:00Z");
-    const { run } = makeTool({ now: () => t0 });
-    const created = await run({
-      action: "create",
-      prompt: "old",
-      schedule: { type: "interval", every: "1h" },
-    });
-    const id = (created.details as ScheduledTask).id;
-    const updated = await run({ action: "update_prompt", id, prompt: "new" });
-    expect((updated.details as ScheduledTask).prompt).toBe("new");
-  });
-});