@fickydev/pigent 0.1.9 → 0.1.11

package/pigent.yaml

@@ -1,5 +1,8 @@
 telegramChats: []
 modelChoices: []
+scheduler:
+  tickIntervalMs: 10000
+  tasks: []
 
 # Optional. If empty, /model uses Pi's currently available models automatically.
 # Add choices to curate or rename buttons for /model.
@@ -20,3 +23,16 @@ modelChoices: []
 #       - assistant
 #     instructions: |
 #       Be concise.
+#
+# Scheduled tasks. Each task runs on interval and sends output to channel.
+# If the agent returns "NOOP", nothing is sent.
+#
+# scheduler:
+#   tickIntervalMs: 10000
+#   tasks:
+#     - id: monitor-build
+#       agent: assistant
+#       intervalMs: 30000
+#       prompt: Check the build pipeline. NOOP if nothing to report.
+#       channel: telegram
+#       chatId: "-100123456"

package/src/agents/AgentRunner.ts

@@ -1,6 +1,5 @@
 import type { InboundMessage } from "../channels/types";
 import type { Repositories } from "../db/repositories";
-import type { AgentSessionRow } from "../db/schema";
 import { logger } from "../logging/logger";
 import { PiAgentRunner } from "../pi/PiAgentRunner";
 import type { AgentRegistry } from "./AgentRegistry";
@@ -11,17 +10,12 @@ export type AgentRunInput = {
   message: InboundMessage;
 };
 
-type AgentRunResponse = {
-  text: string;
-  error?: string;
-};
-
 function sessionLockKey(input: AgentRunInput): string {
   return [input.agentId, input.message.channel, input.message.chatId, input.message.threadId ?? ""].join(":");
 }
 
 export class AgentRunner {
-  private readonly piRunner = new PiAgentRunner();
+  readonly piRunner = new PiAgentRunner();
   private readonly sessionLocks = new Map<string, Promise<void>>();
 
   constructor(
@@ -41,42 +35,38 @@ export class AgentRunner {
       threadId: input.message.threadId,
     });
 
-    await this.repositories.messages.create({
-      agentId: input.agentId,
-      sessionId: session.id,
-      channel: input.message.channel,
-      direction: "inbound",
-      senderId: input.message.senderId,
-      chatId: input.message.chatId,
-      threadId: input.message.threadId,
-      content: input.text,
-      rawJson: input.message.raw,
-    });
-
-    const chatInstructions = await this.chatInstructions(input);
-    const response = await this.createResponse(input, session, chatInstructions);
-
-    if (response.error) {
+    // Skip DB persistence for task-triggered runs (Scheduler handles its own tracking)
+    if (input.message.source !== "task") {
       await this.repositories.messages.create({
         agentId: input.agentId,
         sessionId: session.id,
         channel: input.message.channel,
-        direction: "internal",
+        direction: "inbound",
+        senderId: input.message.senderId,
         chatId: input.message.chatId,
         threadId: input.message.threadId,
-        content: response.error,
+        content: input.text,
+        rawJson: input.message.raw,
       });
     }
 
-    await this.repositories.messages.create({
-      agentId: input.agentId,
-      sessionId: session.id,
-      channel: input.message.channel,
-      direction: "outbound",
-      chatId: input.message.chatId,
-      threadId: input.message.threadId,
-      content: response.text,
-    });
+    const chatInstructions = await this.chatInstructions(input);
+    const response = await this.createResponse(input, session, chatInstructions);
+
+    if (!response.handlerError) {
+      // Task runs persist their own messages via TaskRepository
+      if (input.message.source !== "task") {
+        await this.repositories.messages.create({
+          agentId: input.agentId,
+          sessionId: session.id,
+          channel: input.message.channel,
+          direction: "outbound",
+          chatId: input.message.chatId,
+          threadId: input.message.threadId,
+          content: response.text,
+        });
+      }
+    }
 
     return response.text;
   }
@@ -103,9 +93,9 @@ export class AgentRunner {
 
   private async createResponse(
     input: AgentRunInput,
-    session: AgentSessionRow,
+    session: any,
     chatInstructions: string,
-  ): Promise<AgentRunResponse> {
+  ): Promise<{ text: string; handlerError?: string }> {
     if (process.env.PIGENT_FAKE_AGENT === "1") {
       return { text: this.fakeResponse(input.agentId, input.text) };
     }
@@ -131,26 +121,34 @@ export class AgentRunner {
       });
 
       if (process.env.PIGENT_FALLBACK_FAKE_AGENT === "1") {
-        return { text: this.fakeResponse(input.agentId, input.text), error: errorMessage };
+        return { text: this.fakeResponse(input.agentId, input.text), handlerError: errorMessage };
       }
 
-      return { text: "Agent failed to respond. Please try again later.", error: errorMessage };
+      return { text: "Agent failed to respond. Please try again later.", handlerError: errorMessage };
     }
   }
 
   private composePrompt(input: AgentRunInput, chatInstructions: string): string {
-    return [
+    const parts: string[] = [
       `[Channel]\n${input.message.channel}`,
       `[Chat]\n${input.message.chatId}`,
-      input.message.threadId ? `[Thread]\n${input.message.threadId}` : null,
-      input.message.senderName || input.message.senderId
-        ? `[User]\n${input.message.senderName ?? input.message.senderId}`
-        : null,
-      chatInstructions ? `[Chat Instructions]\n${chatInstructions}` : null,
-      `[Message]\n${input.text}`,
-    ]
-      .filter(Boolean)
-      .join("\n\n");
+    ];
+
+    if (input.message.threadId) {
+      parts.push(`[Thread]\n${input.message.threadId}`);
+    }
+
+    if (input.message.senderName || input.message.senderId) {
+      parts.push(`[User]\n${input.message.senderName ?? input.message.senderId}`);
+    }
+
+    if (chatInstructions) {
+      parts.push(`[Chat Instructions]\n${chatInstructions}`);
+    }
+
+    parts.push(`[Message]\n${input.text}`);
+
+    return parts.join("\n\n");
   }
 
   private async chatInstructions(input: AgentRunInput): Promise<string> {

package/src/agents/BotCommandHandler.ts

@@ -4,6 +4,7 @@ import type { Repositories } from "../db/repositories";
 import { getAvailableModelChoices } from "../pi/PiAvailableModels";
 import { isValidModelRef } from "../pi/PiModelResolver";
 import type { AgentRegistry } from "./AgentRegistry";
+import type { Scheduler } from "../daemon/Scheduler";
 
 export type BotCommandResult =
   | {
@@ -23,12 +24,15 @@ export class BotCommandHandler {
     private readonly registry: AgentRegistry,
     private readonly repositories: Repositories,
     private readonly modelChoices: ModelChoiceConfig[] = [],
+    private readonly scheduler?: Scheduler,
   ) {}
 
   async handle(message: InboundMessage): Promise<BotCommandResult> {
     const [command] = message.text.trim().split(/\s+/, 1);
 
     switch (command) {
+      case "/task":
+        return await this.taskResult(message);
       case "/help":
       case "/start":
         return { handled: true, text: this.helpText() };
@@ -62,6 +66,9 @@ export class BotCommandHandler {
       "/thinking - show thinking picker for this chat session",
       "/thinking <off|low|medium|high> - set thinking level for this chat session",
       "/thinking default - clear thinking override for this chat session",
+      "/task list - list scheduled tasks for this chat",
+      "/task create <intervalMs> <prompt> - create a scheduled task",
+      "/task remove <id> - remove a scheduled task",
       "/agent <agentId> <message> - send message to specific agent",
       "@agentId <message> - send message to specific agent",
     ].join("\n");
@@ -84,8 +91,8 @@ export class BotCommandHandler {
     }
 
     return [
-      `Default agent: ${chat.defaultAgentId ?? "none"}`,
-      `Allowed agents: ${allowedAgentIds.length > 0 ? allowedAgentIds.join(", ") : "none"}`,
+      "Default agent: " + (chat.defaultAgentId ?? "none"),
+      "Allowed agents: " + (allowedAgentIds.length > 0 ? allowedAgentIds.join(", ") : "none"),
     ].join("\n");
   }
 
@@ -102,8 +109,8 @@ export class BotCommandHandler {
       return {
         handled: true,
         text: [
-          `Agent: ${sessionResult.agentId}`,
-          `Session model: ${sessionResult.session.model ?? "default"}`,
+          "Agent: " + sessionResult.agentId,
+          "Session model: " + (sessionResult.session.model ?? "default"),
           choices.length > 0
             ? "Choose a model:"
             : "No available Pi models found. Configure provider auth or use /model <provider/modelId> manually.",
@@ -121,7 +128,7 @@ export class BotCommandHandler {
     }
 
     const session = await this.repositories.sessions.updateModel(sessionResult.session.id, value);
-    return { handled: true, text: `Session model for ${session.agentId} set to ${session.model}.` };
+    return { handled: true, text: "Session model for " + session.agentId + " set to " + session.model + "." };
   }
 
   private async thinkingResult(message: InboundMessage): Promise<BotCommandResult> {
@@ -135,8 +142,8 @@ export class BotCommandHandler {
       return {
         handled: true,
         text: [
-          `Agent: ${sessionResult.agentId}`,
-          `Session thinking level: ${sessionResult.session.thinkingLevel ?? "default"}`,
+          "Agent: " + sessionResult.agentId,
+          "Session thinking level: " + (sessionResult.session.thinkingLevel ?? "default"),
           "Choose thinking level:",
         ].join("\n"),
         inlineKeyboard: this.thinkingKeyboard(),
@@ -152,7 +159,7 @@ export class BotCommandHandler {
     }
 
     const session = await this.repositories.sessions.updateThinkingLevel(sessionResult.session.id, value);
-    return { handled: true, text: `Session thinking level for ${session.agentId} set to ${session.thinkingLevel}.` };
+    return { handled: true, text: "Session thinking level for " + session.agentId + " set to " + session.thinkingLevel + "." };
   }
 
   private async setModelFromChoice(message: InboundMessage): Promise<string> {
@@ -167,7 +174,7 @@ export class BotCommandHandler {
 
     const choice = choices[choiceIndex];
     const session = await this.repositories.sessions.updateModel(sessionResult.session.id, choice.id);
-    return `Session model for ${session.agentId} set to ${choice.label} (${session.model}).`;
+    return "Session model for " + session.agentId + " set to " + choice.label + " (" + session.model + ").";
   }
 
   private async clearModel(message: InboundMessage): Promise<string> {
@@ -175,7 +182,7 @@ export class BotCommandHandler {
     if (!sessionResult.ok) return sessionResult.message;
 
     const session = await this.repositories.sessions.updateModel(sessionResult.session.id, null);
-    return `Session model cleared for ${session.agentId}. Current: ${session.model ?? "default"}`;
+    return "Session model cleared for " + session.agentId + ". Current: " + (session.model ?? "default");
   }
 
   private async setThinkingFromCallback(message: InboundMessage): Promise<string> {
@@ -188,7 +195,7 @@ export class BotCommandHandler {
     }
 
     const session = await this.repositories.sessions.updateThinkingLevel(sessionResult.session.id, value);
-    return `Session thinking level for ${session.agentId} set to ${session.thinkingLevel}.`;
+    return "Session thinking level for " + session.agentId + " set to " + session.thinkingLevel + ".";
   }
 
   private async clearThinking(message: InboundMessage): Promise<string> {
@@ -196,7 +203,94 @@ export class BotCommandHandler {
     if (!sessionResult.ok) return sessionResult.message;
 
     const session = await this.repositories.sessions.updateThinkingLevel(sessionResult.session.id, null);
-    return `Session thinking level cleared for ${session.agentId}. Current: ${session.thinkingLevel ?? "default"}`;
+    return "Session thinking level cleared for " + session.agentId + ". Current: " + (session.thinkingLevel ?? "default");
+  }
+
+  private async taskResult(message: InboundMessage): Promise<BotCommandResult> {
+    if (!this.scheduler) {
+      return { handled: true, text: "Scheduler is not available." };
+    }
+
+    const parts = message.text.trim().split(/\s+/);
+    const subcommand = parts[1];
+
+    if (subcommand === "list") {
+      return await this.taskList(message);
+    }
+
+    if (subcommand === "create") {
+      return await this.taskCreate(message, parts);
+    }
+
+    if (subcommand === "remove") {
+      return await this.taskRemove(parts);
+    }
+
+    return {
+      handled: true,
+      text: [
+        "Usage:",
+        "/task list - list scheduled tasks",
+        "/task create <intervalMs> <prompt> - create a task",
+        "/task remove <id> - remove a task",
+      ].join("\n"),
+    };
+  }
+
+  private async taskList(message: InboundMessage): Promise<BotCommandResult> {
+    const tasks = this.scheduler!.getTasks().filter((t) => t.chatId === message.chatId || !t.chatId);
+    if (tasks.length === 0) return { handled: true, text: "No scheduled tasks for this chat." };
+
+    const lines = tasks.map((t) => {
+      const truncated = t.prompt.length > 50 ? t.prompt.slice(0, 50) + "..." : t.prompt;
+      return "- " + t.id + ": " + t.agent + " every " + t.intervalMs + 'ms "' + truncated + '"';
+    });
+
+    return { handled: true, text: "Scheduled tasks:\n" + lines.join("\n") };
+  }
+
+  private async taskCreate(message: InboundMessage, parts: string[]): Promise<BotCommandResult> {
+    const intervalMs = Number(parts[2]);
+    if (!Number.isInteger(intervalMs) || intervalMs < 1000) {
+      return { handled: true, text: "Invalid interval. Use a number >= 1000 (milliseconds)." };
+    }
+
+    const prompt = parts.slice(3).join(" ").trim();
+    if (!prompt) {
+      return { handled: true, text: "Missing prompt. Usage: /task create <intervalMs> <prompt>" };
+    }
+
+    const chat = await this.repositories.telegram.findChat(message.chatId);
+    if (!chat?.defaultAgentId) {
+      return { handled: true, text: "No default agent configured for this chat. Set one first." };
+    }
+
+    const saved = await this.scheduler!.addDynamicTask({
+      agent: chat.defaultAgentId,
+      intervalMs,
+      prompt,
+      channel: "telegram",
+      chatId: message.chatId,
+    });
+
+    const msg = "Task created: " + saved.id + "\n"
+      + "Agent: " + saved.agent + "\n"
+      + "Interval: " + saved.intervalMs + "ms\n"
+      + "Prompt: " + saved.prompt;
+
+    return { handled: true, text: msg };
+  }
+
+  private async taskRemove(parts: string[]): Promise<BotCommandResult> {
+    const taskId = parts[2];
+    if (!taskId) {
+      return { handled: true, text: "Missing task id. Usage: /task remove <id>" };
+    }
+
+    const removed = await this.scheduler!.removeDynamicTask(taskId);
+    if (!removed) return { handled: true, text: "Task not found: " + taskId };
+
+    return { handled: true, text: "Task removed: " + taskId };
   }
 
   private async loadModelChoices(): Promise<ModelChoiceConfig[]> {
@@ -209,7 +303,7 @@ export class BotCommandHandler {
     const rows = chunk(
       choices.map((choice, index) => ({
         text: choice.label,
-        callbackData: `model:set:${index}`,
+        callbackData: "model:set:" + index,
       })),
       1,
     );
@@ -250,11 +344,11 @@ export class BotCommandHandler {
     }
 
     if (!this.registry.hasAgent(agentId)) {
-      return { ok: false as const, message: `Unknown agent: ${agentId}` };
+      return { ok: false as const, message: "Unknown agent: " + agentId };
     }
 
     if (!(await this.repositories.telegram.isAgentAllowed(message.chatId, agentId))) {
-      return { ok: false as const, message: `Agent is not allowed in this chat: ${agentId}` };
+      return { ok: false as const, message: "Agent is not allowed in this chat: " + agentId };
     }
 
     const session = await this.repositories.sessions.getOrCreate({

package/src/channels/types.ts

@@ -1,5 +1,7 @@
 export type ChannelId = "telegram";
 
+export type MessageSource = "user" | "task";
+
 export type InboundMessage = {
   id: string;
   channel: ChannelId;
@@ -10,6 +12,7 @@ export type InboundMessage = {
   text: string;
   raw: unknown;
   receivedAt: Date;
+  source?: MessageSource;
 };
 
 export type InlineKeyboardButton = {

package/src/config/loadConfig.ts

@@ -112,5 +112,6 @@ export async function loadConfig(options: LoadConfigOptions = {}): Promise<Loade
     profiles,
     telegramChats: rootConfig.telegramChats,
     modelChoices: rootConfig.modelChoices,
+    scheduler: rootConfig.scheduler,
   };
 }

package/src/config/schemas.ts

@@ -11,10 +11,18 @@ export const PermissionConfigSchema = z.object({
   blockedTools: z.array(z.string()).default([]),
 });
 
-export const HeartbeatConfigSchema = z.object({
-  enabled: z.boolean().default(false),
+export const TaskConfigSchema = z.object({
+  id: z.string().min(1),
+  agent: z.string().min(1),
   intervalMs: z.number().int().positive().default(600_000),
   prompt: z.string().min(1).default("If no useful action is needed, reply exactly: NOOP."),
+  channel: z.string().default("telegram"),
+  chatId: z.string().optional(),
+});
+
+export const SchedulerConfigSchema = z.object({
+  tickIntervalMs: z.number().int().positive().default(10_000),
+  tasks: z.array(TaskConfigSchema).default([]),
 });
 
 export const AgentTelegramChannelConfigSchema = z.object({
@@ -36,11 +44,6 @@ export const AgentConfigSchema = z.object({
   skills: z.array(z.string()).default([]),
   extensions: z.array(z.string()).default([]),
   channels: AgentChannelsConfigSchema.default({ telegram: { enabled: false } }),
-  heartbeat: HeartbeatConfigSchema.default({
-    enabled: false,
-    intervalMs: 600_000,
-    prompt: "If no useful action is needed, reply exactly: NOOP.",
-  }),
   permissions: PermissionConfigSchema.default({
     canRunShell: false,
     canEditFiles: false,
@@ -82,10 +85,12 @@ export const TelegramChatConfigSchema = z.object({
 export const RootConfigSchema = z.object({
   telegramChats: z.array(TelegramChatConfigSchema).default([]),
   modelChoices: z.array(ModelChoiceConfigSchema).default([]),
+  scheduler: SchedulerConfigSchema.default({ tickIntervalMs: 10_000, tasks: [] }),
 });
 
 export type PermissionConfig = z.infer<typeof PermissionConfigSchema>;
-export type HeartbeatConfig = z.infer<typeof HeartbeatConfigSchema>;
+export type TaskConfig = z.infer<typeof TaskConfigSchema>;
+export type SchedulerConfig = z.infer<typeof SchedulerConfigSchema>;
 export type AgentConfig = z.infer<typeof AgentConfigSchema>;
 export type ProfileConfig = z.infer<typeof ProfileConfigSchema>;
 export type TelegramChatConfig = z.infer<typeof TelegramChatConfigSchema>;
@@ -102,4 +107,5 @@ export type LoadedConfig = {
   profiles: ProfileConfig[];
   telegramChats: TelegramChatConfig[];
   modelChoices: ModelChoiceConfig[];
+  scheduler: SchedulerConfig;
 };

package/src/daemon/AgentDaemon.ts

@@ -9,6 +9,7 @@ import { loadConfig } from "../config/loadConfig";
 import type { LoadedConfig } from "../config/schemas";
 import { createRepositories, type Repositories } from "../db/repositories";
 import { logger } from "../logging/logger";
+import { Scheduler } from "./Scheduler";
 
 export class AgentDaemon {
   private running = false;
@@ -17,6 +18,7 @@ export class AgentDaemon {
   private readonly registry: AgentRegistry;
   private readonly router: MessageRouter;
   private readonly runner: AgentRunner;
+  private readonly scheduler: Scheduler;
 
   private constructor(
     private readonly config: LoadedConfig,
@@ -24,9 +26,10 @@ export class AgentDaemon {
   ) {
     this.adapters = createAdapters(repositories);
     this.registry = new AgentRegistry(config, repositories);
-    this.commands = new BotCommandHandler(this.registry, repositories, config.modelChoices);
-    this.router = new MessageRouter(repositories, this.registry);
     this.runner = new AgentRunner(this.registry, repositories);
+    this.scheduler = new Scheduler(config.scheduler, this.registry, repositories, this.adapters, this.runner);
+    this.commands = new BotCommandHandler(this.registry, repositories, config.modelChoices, this.scheduler);
+    this.router = new MessageRouter(repositories, this.registry);
   }
 
   static async create(): Promise<AgentDaemon> {
@@ -45,6 +48,8 @@ export class AgentDaemon {
       await adapter.start((message) => this.handleInboundMessage(message));
     }
 
+    await this.scheduler.start();
+
     logger.info("pigent daemon started", {
       agents: this.registry.listAgents().length,
       profiles: this.registry.listProfiles().length,
@@ -58,6 +63,8 @@ export class AgentDaemon {
 
     this.running = false;
 
+    this.scheduler.stop();
+
     for (const adapter of this.adapters) {
       await adapter.stop();
     }