@fickydev/pigent 0.1.9 → 0.1.11

package/src/daemon/Scheduler.ts

@@ -0,0 +1,223 @@
+import type { SchedulerConfig, TaskConfig } from "../config/schemas";
+import type { Repositories } from "../db/repositories";
+import type { TaskConfigRow } from "../db/schema";
+import { logger } from "../logging/logger";
+import type { AgentRegistry } from "../agents/AgentRegistry";
+import type { AgentRunner } from "../agents/AgentRunner";
+import type { ChannelAdapter } from "../channels/types";
+import { isTaskDue } from "./taskDue";
+
+export class Scheduler {
+  private running = false;
+  private tickTimer: ReturnType<typeof setTimeout> | null = null;
+  private readonly taskLocks = new Map<string, boolean>();
+  private tasks: TaskConfig[] = [];
+
+  constructor(
+    private readonly schedulerConfig: SchedulerConfig,
+    private readonly registry: AgentRegistry,
+    private readonly repositories: Repositories,
+    private readonly adapters: ChannelAdapter[],
+    private readonly agentRunner: AgentRunner,
+  ) {}
+
+  async start(): Promise<void> {
+    if (this.running) return;
+
+    this.tasks = await this.loadAllTasks();
+
+    if (this.tasks.length === 0) {
+      logger.info("scheduler skipped — no tasks configured");
+      return;
+    }
+
+    this.running = true;
+    logger.info("scheduler started", {
+      tickIntervalMs: this.schedulerConfig.tickIntervalMs,
+      taskCount: this.tasks.length,
+    });
+    this.tick();
+  }
+
+  stop(): void {
+    if (!this.running) return;
+    this.running = false;
+    if (this.tickTimer !== null) {
+      clearTimeout(this.tickTimer);
+      this.tickTimer = null;
+    }
+    logger.info("scheduler stopped");
+  }
+
+  getTasks(): TaskConfig[] {
+    return [...this.tasks];
+  }
+
+  /** Add a runtime-created task (from Telegram). Saves to DB, hot-adds to scheduler. */
+  async addDynamicTask(input: {
+    agent: string;
+    intervalMs: number;
+    prompt: string;
+    channel: string;
+    chatId: string;
+  }): Promise<TaskConfigRow> {
+    const saved = await this.repositories.taskConfigs.create(input);
+
+    this.tasks.push({
+      id: saved.id,
+      agent: saved.agent,
+      intervalMs: saved.intervalMs,
+      prompt: saved.prompt,
+      channel: saved.channel,
+      chatId: saved.chatId,
+    });
+
+    if (!this.running && this.tasks.length === 1) {
+      // First task added, start scheduler
+      this.running = true;
+      this.tick();
+      logger.info("scheduler started on first dynamic task");
+    }
+
+    return saved;
+  }
+
+  /** Remove a runtime task. Deletes from DB, hot-removes from scheduler. */
+  async removeDynamicTask(id: string): Promise<boolean> {
+    const before = this.tasks.length;
+    this.tasks = this.tasks.filter((t) => t.id !== id);
+    await this.repositories.taskConfigs.remove(id);
+
+    const removed = this.tasks.length < before;
+
+    if (removed && this.tasks.length === 0 && this.running) {
+      this.stop();
+    }
+
+    return removed;
+  }
+
+  private async loadAllTasks(): Promise<TaskConfig[]> {
+    const configTasks: TaskConfig[] = this.schedulerConfig.tasks;
+    const dbTasks = await this.repositories.taskConfigs.findAllEnabled();
+
+    const dbTaskConfigs: TaskConfig[] = dbTasks.map((row) => ({
+      id: row.id,
+      agent: row.agent,
+      intervalMs: row.intervalMs,
+      prompt: row.prompt,
+      channel: row.channel,
+      chatId: row.chatId,
+    }));
+
+    return [...configTasks, ...dbTaskConfigs];
+  }
+
+  private tick(): void {
+    if (!this.running) return;
+
+    for (const task of this.tasks) {
+      this.runTaskIfDue(task);
+    }
+
+    this.tickTimer = setTimeout(() => this.tick(), this.schedulerConfig.tickIntervalMs);
+  }
+
+  private async runTaskIfDue(task: TaskConfig): Promise<void> {
+    if (this.taskLocks.get(task.id)) return;
+
+    const lastRun = await this.repositories.taskRuns.findLatest(task.agent, task.id);
+    if (!isTaskDue(lastRun?.createdAt ?? null, task.intervalMs)) return;
+
+    const agent = this.registry.getAgent(task.agent);
+    if (!agent) {
+      logger.warn("task references unknown agent, skipping", { taskId: task.id, agent: task.agent });
+      return;
+    }
+
+    this.taskLocks.set(task.id, true);
+
+    try {
+      await this.executeTask(task, agent);
+    } finally {
+      this.taskLocks.set(task.id, false);
+    }
+  }
+
+  private async executeTask(task: TaskConfig, agent: any): Promise<void> {
+    logger.info("task executing", { taskId: task.id, agentId: task.agent });
+
+    const run = await this.repositories.taskRuns.create({
+      agentId: task.agent,
+      taskId: task.id,
+      prompt: task.prompt,
+    });
+
+    await this.repositories.taskRuns.markRunning(run.id);
+
+    try {
+      const fullPrompt = this.composeTaskPrompt(task);
+
+      // Use AgentRunner to run the prompt — shares the session lock with user messages
+      const response = await this.agentRunner.run({
+        agentId: task.agent,
+        text: fullPrompt,
+        message: {
+          id: "task:" + task.id,
+          channel: task.channel as any,
+          chatId: task.chatId!,
+          text: fullPrompt,
+          raw: { type: "task", taskId: task.id },
+          receivedAt: new Date(),
+          source: "task",
+        },
+      });
+
+      const trimmed = response.trim();
+
+      if (trimmed.toUpperCase() === "NOOP") {
+        await this.repositories.taskRuns.markNoop(run.id, { result: response });
+        logger.info("task noop", { taskId: task.id });
+        return;
+      }
+
+      await this.repositories.taskRuns.markNotified(run.id, { result: response });
+      await this.sendToChannel(task, agent, response);
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      logger.error("task failed", { taskId: task.id, error: errorMessage });
+      await this.repositories.taskRuns.markFailed(run.id, { error: errorMessage });
+    }
+  }
+
+  private async sendToChannel(task: TaskConfig, agent: any, text: string): Promise<void> {
+    const adapter = this.adapters.find((a) => a.id === task.channel);
+    if (!adapter) {
+      logger.warn("no adapter for task output", { taskId: task.id, channel: task.channel });
+      return;
+    }
+
+    if (!task.chatId) {
+      logger.warn("no chatId for task output", { taskId: task.id });
+      return;
+    }
+
+    await adapter.send({
+      channel: task.channel as any,
+      chatId: task.chatId,
+      text: `[${agent.name} / ${task.id}]\n${text}`,
+    });
+  }
+
+  private composeTaskPrompt(task: TaskConfig): string {
+    return [
+      `[Task: ${task.id}]`,
+      "",
+      task.prompt,
+      "",
+      "You are running as a scheduled task inside Pigent.",
+      "If no useful action is needed, reply exactly: NOOP.",
+      "Otherwise, reply with the result of your task.",
+    ].join("\n");
+  }
+}

package/src/daemon/taskDue.ts

@@ -0,0 +1,4 @@
+export function isTaskDue(lastRunCreatedAt: number | null, intervalMs: number, now = Date.now()): boolean {
+  if (lastRunCreatedAt === null) return true;
+  return now - lastRunCreatedAt >= intervalMs;
+}

package/src/db/repositories/TaskConfigRepository.ts

@@ -0,0 +1,63 @@
+import { eq } from "drizzle-orm";
+import { nanoid } from "nanoid";
+import type { DbClient } from "../client";
+import { taskConfigs, type TaskConfigRow } from "../schema";
+
+export type CreateTaskConfigInput = {
+  agent: string;
+  intervalMs: number;
+  prompt: string;
+  channel: string;
+  chatId: string;
+};
+
+export class TaskConfigRepository {
+  constructor(private readonly db: DbClient) {}
+
+  async create(input: CreateTaskConfigInput): Promise<TaskConfigRow> {
+    const id = nanoid(8);
+    const now = Date.now();
+
+    await this.db.insert(taskConfigs).values({
+      id,
+      agent: input.agent,
+      intervalMs: input.intervalMs,
+      prompt: input.prompt,
+      channel: input.channel,
+      chatId: input.chatId,
+      enabled: true,
+      createdAt: now,
+      updatedAt: now,
+    });
+
+    const row = await this.findById(id);
+    if (!row) throw new Error(`failed to create task config ${id}`);
+
+    return row;
+  }
+
+  async remove(id: string): Promise<void> {
+    await this.db.delete(taskConfigs).where(eq(taskConfigs.id, id));
+  }
+
+  async findById(id: string): Promise<TaskConfigRow | null> {
+    const row = await this.db.query.taskConfigs.findFirst({
+      where: eq(taskConfigs.id, id),
+    });
+
+    return row ?? null;
+  }
+
+  async findAllByChatId(chatId: string): Promise<TaskConfigRow[]> {
+    return this.db.query.taskConfigs.findMany({
+      where: eq(taskConfigs.chatId, chatId),
+      orderBy: (fields, { asc }) => [asc(fields.createdAt)],
+    });
+  }
+
+  async findAllEnabled(): Promise<TaskConfigRow[]> {
+    return this.db.query.taskConfigs.findMany({
+      where: eq(taskConfigs.enabled, true),
+    });
+  }
+}

package/src/db/repositories/TaskRepository.ts

@@ -0,0 +1,129 @@
+import { and, desc, eq, gte } from "drizzle-orm";
+import { nanoid } from "nanoid";
+import type { DbClient } from "../client";
+import { taskRuns, type TaskRunRow } from "../schema";
+
+export type TaskRunStatus = "pending" | "running" | "noop" | "notified" | "failed";
+
+export type CreateTaskRunInput = {
+  agentId: string;
+  taskId: string;
+  prompt: string;
+  sessionId?: string | null;
+  status?: Extract<TaskRunStatus, "pending" | "running">;
+  startedAt?: number | null;
+};
+
+export type FinishTaskRunInput = {
+  result?: string | null;
+  error?: string | null;
+  finishedAt?: number;
+};
+
+export class TaskRepository {
+  constructor(private readonly db: DbClient) {}
+
+  async create(input: CreateTaskRunInput): Promise<TaskRunRow> {
+    const id = nanoid();
+    const now = Date.now();
+
+    await this.db.insert(taskRuns).values({
+      id,
+      agentId: input.agentId,
+      taskId: input.taskId,
+      prompt: input.prompt,
+      sessionId: input.sessionId ?? null,
+      status: input.status ?? "pending",
+      result: null,
+      error: null,
+      startedAt: input.startedAt ?? null,
+      finishedAt: null,
+      createdAt: now,
+    });
+
+    const row = await this.findById(id);
+    if (!row) throw new Error(`failed to create task run ${id}`);
+
+    return row;
+  }
+
+  async markRunning(id: string, startedAt = Date.now()): Promise<TaskRunRow> {
+    await this.db
+      .update(taskRuns)
+      .set({ status: "running", startedAt })
+      .where(eq(taskRuns.id, id));
+
+    return this.requireById(id);
+  }
+
+  async markNoop(id: string, input: FinishTaskRunInput = {}): Promise<TaskRunRow> {
+    return this.finish(id, "noop", input);
+  }
+
+  async markNotified(id: string, input: FinishTaskRunInput = {}): Promise<TaskRunRow> {
+    return this.finish(id, "notified", input);
+  }
+
+  async markFailed(id: string, input: FinishTaskRunInput): Promise<TaskRunRow> {
+    return this.finish(id, "failed", input);
+  }
+
+  async findById(id: string): Promise<TaskRunRow | null> {
+    const row = await this.db.query.taskRuns.findFirst({
+      where: eq(taskRuns.id, id),
+    });
+
+    return row ?? null;
+  }
+
+  async findLatest(agentId: string, taskId: string): Promise<TaskRunRow | null> {
+    const row = await this.db.query.taskRuns.findFirst({
+      where: and(eq(taskRuns.agentId, agentId), eq(taskRuns.taskId, taskId)),
+      orderBy: desc(taskRuns.createdAt),
+    });
+
+    return row ?? null;
+  }
+
+  async countRecentNotified(agentId: string, taskId: string, since: number): Promise<number> {
+    const conditions: any[] = [
+      eq(taskRuns.agentId, agentId),
+      eq(taskRuns.taskId, taskId),
+      eq(taskRuns.status, "notified"),
+    ];
+
+    const rows = await this.db.query.taskRuns.findMany({
+      where: and(gte(taskRuns.finishedAt, since), ...conditions),
+      columns: { id: true },
+    });
+
+    return rows.length;
+  }
+
+  private async finish(
+    id: string,
+    status: Extract<TaskRunStatus, "noop" | "notified" | "failed">,
+    input: FinishTaskRunInput,
+  ): Promise<TaskRunRow> {
+    await this.db
+      .update(taskRuns)
+      .set({
+        status,
+        result: input.result ?? null,
+        error: input.error ?? null,
+        finishedAt: input.finishedAt ?? Date.now(),
+      })
+      .where(eq(taskRuns.id, id));
+
+    return this.requireById(id);
+  }
+
+  private async requireById(id: string): Promise<TaskRunRow> {
+    const row = await this.findById(id);
+    if (!row) throw new Error(`task run not found ${id}`);
+
+    return row;
+  }
+}
+
+

package/src/db/repositories/index.ts

@@ -4,6 +4,8 @@ import { HeartbeatRepository } from "./HeartbeatRepository";
 import { MessageRepository } from "./MessageRepository";
 import { RuntimeKvRepository } from "./RuntimeKvRepository";
 import { SessionRepository } from "./SessionRepository";
+import { TaskConfigRepository } from "./TaskConfigRepository";
+import { TaskRepository } from "./TaskRepository";
 import { TelegramRepository } from "./TelegramRepository";
 
 export type Repositories = ReturnType<typeof createRepositories>;
@@ -15,6 +17,8 @@ export function createRepositories(dbClient = db) {
     messages: new MessageRepository(dbClient),
     runtimeKv: new RuntimeKvRepository(dbClient),
     sessions: new SessionRepository(dbClient),
+    taskConfigs: new TaskConfigRepository(dbClient),
+    taskRuns: new TaskRepository(dbClient),
     telegram: new TelegramRepository(dbClient),
   };
 }

package/src/db/schema.ts

@@ -90,6 +90,32 @@ export const heartbeats = sqliteTable("heartbeats", {
   createdAt: integer("created_at").notNull(),
 });
 
+export const taskRuns = sqliteTable("task_runs", {
+  id: text("id").primaryKey(),
+  agentId: text("agent_id").notNull(),
+  taskId: text("task_id").notNull(),
+  prompt: text("prompt").notNull(),
+  sessionId: text("session_id"),
+  status: text("status", { enum: ["pending", "running", "noop", "notified", "failed"] }).notNull(),
+  result: text("result"),
+  error: text("error"),
+  startedAt: integer("started_at"),
+  finishedAt: integer("finished_at"),
+  createdAt: integer("created_at").notNull(),
+});
+
+export const taskConfigs = sqliteTable("task_configs", {
+  id: text("id").primaryKey(),
+  agent: text("agent").notNull(),
+  intervalMs: integer("interval_ms").notNull(),
+  prompt: text("prompt").notNull(),
+  channel: text("channel").notNull().default("telegram"),
+  chatId: text("chat_id").notNull(),
+  enabled: integer("enabled", { mode: "boolean" }).notNull().default(true),
+  createdAt: integer("created_at").notNull(),
+  updatedAt: integer("updated_at").notNull(),
+});
+
 export const runtimeKv = sqliteTable("runtime_kv", {
   key: text("key").primaryKey(),
   value: text("value").notNull(),
@@ -106,3 +132,7 @@ export type MessageRow = typeof messages.$inferSelect;
 export type NewMessageRow = typeof messages.$inferInsert;
 export type HeartbeatRow = typeof heartbeats.$inferSelect;
 export type NewHeartbeatRow = typeof heartbeats.$inferInsert;
+export type TaskRunRow = typeof taskRuns.$inferSelect;
+export type NewTaskRunRow = typeof taskRuns.$inferInsert;
+export type TaskConfigRow = typeof taskConfigs.$inferSelect;
+export type NewTaskConfigRow = typeof taskConfigs.$inferInsert;