@fickydev/pigent 0.1.0

package/src/agents/AgentRunner.ts

@@ -0,0 +1,112 @@
+import type { InboundMessage } from "../channels/types";
+import type { LoadedAgentConfig, LoadedConfig, ProfileConfig } from "../config/schemas";
+import type { Repositories } from "../db/repositories";
+import { logger } from "../logging/logger";
+import { PiAgentRunner } from "../pi/PiAgentRunner";
+
+export type AgentRunInput = {
+  agentId: string;
+  text: string;
+  message: InboundMessage;
+};
+
+export class AgentRunner {
+  private readonly piRunner = new PiAgentRunner();
+
+  constructor(
+    private readonly config: LoadedConfig,
+    private readonly repositories: Repositories,
+  ) {}
+
+  async run(input: AgentRunInput): Promise<string> {
+    const session = await this.repositories.sessions.getOrCreate({
+      agentId: input.agentId,
+      channel: input.message.channel,
+      chatId: input.message.chatId,
+      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 response = await this.createResponse(input);
+
+    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,
+    });
+
+    return response;
+  }
+
+  private async createResponse(input: AgentRunInput): Promise<string> {
+    if (process.env.PIGENT_FAKE_AGENT === "1") {
+      return this.fakeResponse(input.agentId, input.text);
+    }
+
+    const agent = this.findAgent(input.agentId);
+    if (!agent) return `Unknown agent: ${input.agentId}`;
+
+    try {
+      return await this.piRunner.run({
+        agent,
+        profile: this.findProfile(agent.profile),
+        prompt: this.composePrompt(input),
+      });
+    } catch (error) {
+      logger.error("pi runner failed", {
+        agentId: input.agentId,
+        error: error instanceof Error ? error.message : String(error),
+      });
+
+      if (process.env.PIGENT_FALLBACK_FAKE_AGENT === "1") {
+        return this.fakeResponse(input.agentId, input.text);
+      }
+
+      return "Agent execution failed. Check daemon logs.";
+    }
+  }
+
+  private composePrompt(input: AgentRunInput): string {
+    return [
+      `[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,
+      `[Message]\n${input.text}`,
+    ]
+      .filter(Boolean)
+      .join("\n\n");
+  }
+
+  private fakeResponse(agentId: string, text: string): string {
+    const agent = this.findAgent(agentId);
+    const name = agent?.name ?? agentId;
+
+    return `[${name}] fake runner received: ${text || "(empty message)"}`;
+  }
+
+  private findAgent(agentId: string): LoadedAgentConfig | null {
+    return this.config.agents.find((candidate) => candidate.id === agentId) ?? null;
+  }
+
+  private findProfile(profileId: string): ProfileConfig | null {
+    return this.config.profiles.find((candidate) => candidate.id === profileId) ?? null;
+  }
+}

package/src/agents/BotCommandHandler.ts

@@ -0,0 +1,65 @@
+import type { InboundMessage } from "../channels/types";
+import type { LoadedConfig } from "../config/schemas";
+import type { Repositories } from "../db/repositories";
+
+export type BotCommandResult =
+  | {
+      handled: true;
+      text: string;
+    }
+  | {
+      handled: false;
+    };
+
+export class BotCommandHandler {
+  constructor(
+    private readonly config: LoadedConfig,
+    private readonly repositories: Repositories,
+  ) {}
+
+  async handle(message: InboundMessage): Promise<BotCommandResult> {
+    const [command] = message.text.trim().split(/\s+/, 1);
+
+    switch (command) {
+      case "/help":
+      case "/start":
+        return { handled: true, text: this.helpText() };
+      case "/agents":
+        return { handled: true, text: await this.agentsText(message) };
+      default:
+        return { handled: false };
+    }
+  }
+
+  private helpText(): string {
+    return [
+      "Pigent commands:",
+      "/help - show this help",
+      "/agents - list agents for this chat",
+      "/agent <agentId> <message> - send message to specific agent",
+      "@agentId <message> - send message to specific agent",
+    ].join("\n");
+  }
+
+  private async agentsText(message: InboundMessage): Promise<string> {
+    const chat = await this.repositories.telegram.findChat(message.chatId);
+
+    if (!chat) {
+      return "No agents configured for this chat.";
+    }
+
+    const allAgentIds = this.config.agents.map((agent) => agent.id);
+    const allowedAgentIds = [];
+
+    for (const agentId of allAgentIds) {
+      if (await this.repositories.telegram.isAgentAllowed(message.chatId, agentId)) {
+        allowedAgentIds.push(agentId);
+      }
+    }
+
+    return [
+      `Default agent: ${chat.defaultAgentId ?? "none"}`,
+      `Allowed agents: ${allowedAgentIds.length > 0 ? allowedAgentIds.join(", ") : "none"}`,
+    ].join("\n");
+  }
+}

package/src/agents/MessageRouter.ts

@@ -0,0 +1,106 @@
+import type { InboundMessage } from "../channels/types";
+import type { Repositories } from "../db/repositories";
+
+export type RouteResult =
+  | {
+      ok: true;
+      agentId: string;
+      text: string;
+    }
+  | {
+      ok: false;
+      reason: "unknown_agent" | "disallowed_agent" | "no_default_agent" | "chat_disabled";
+      message: string;
+    };
+
+export class MessageRouter {
+  constructor(private readonly repositories: Repositories) {}
+
+  async route(message: InboundMessage): Promise<RouteResult> {
+    if (message.channel !== "telegram") {
+      return {
+        ok: false,
+        reason: "no_default_agent",
+        message: "Unsupported channel.",
+      };
+    }
+
+    const chat = await this.repositories.telegram.findChat(message.chatId);
+
+    if (!chat) {
+      return {
+        ok: false,
+        reason: "no_default_agent",
+        message: "No default agent configured for this chat.",
+      };
+    }
+
+    if (!chat.enabled) {
+      return {
+        ok: false,
+        reason: "chat_disabled",
+        message: "This chat is disabled.",
+      };
+    }
+
+    const parsed = parseAgentCommand(message.text);
+    const agentId = parsed.agentId ?? chat.defaultAgentId;
+
+    if (!agentId) {
+      return {
+        ok: false,
+        reason: "no_default_agent",
+        message: "No default agent configured for this chat.",
+      };
+    }
+
+    const agent = await this.repositories.agents.findById(agentId);
+    if (!agent) {
+      return {
+        ok: false,
+        reason: "unknown_agent",
+        message: `Unknown agent: ${agentId}`,
+      };
+    }
+
+    const allowed = await this.repositories.telegram.isAgentAllowed(message.chatId, agentId);
+    if (!allowed) {
+      return {
+        ok: false,
+        reason: "disallowed_agent",
+        message: `Agent is not allowed in this chat: ${agentId}`,
+      };
+    }
+
+    return {
+      ok: true,
+      agentId,
+      text: parsed.text,
+    };
+  }
+}
+
+function parseAgentCommand(text: string): { agentId: string | null; text: string } {
+  const trimmed = text.trim();
+
+  const mentionMatch = trimmed.match(/^@([a-zA-Z0-9_-]+)\b\s*(.*)$/s);
+  if (mentionMatch) {
+    return {
+      agentId: mentionMatch[1],
+      text: mentionMatch[2]?.trim() ?? "",
+    };
+  }
+
+  const slashMatch = trimmed.match(/^\/agent\s+([a-zA-Z0-9_-]+)\b\s*(.*)$/s);
+  if (slashMatch) {
+    return {
+      agentId: slashMatch[1],
+      text: slashMatch[2]?.trim() ?? "",
+    };
+  }
+
+  return {
+    agentId: null,
+    text: trimmed,
+  };
+}

package/src/channels/telegram/TelegramApi.ts

@@ -0,0 +1,67 @@
+import type { TelegramGetMeResponse, TelegramGetUpdatesResponse, TelegramSendMessageResponse, TelegramUpdate, TelegramUser } from "./types";
+
+export type TelegramApiOptions = {
+  token: string;
+  baseUrl?: string;
+};
+
+export type GetUpdatesOptions = {
+  offset?: number;
+  timeoutSeconds?: number;
+  limit?: number;
+};
+
+export class TelegramApi {
+  private readonly baseUrl: string;
+
+  constructor(options: TelegramApiOptions) {
+    this.baseUrl = options.baseUrl ?? `https://api.telegram.org/bot${options.token}`;
+  }
+
+  async getMe(): Promise<TelegramUser> {
+    const response = await this.request<TelegramGetMeResponse>("getMe", {});
+    return response.result;
+  }
+
+  async getUpdates(options: GetUpdatesOptions = {}): Promise<TelegramUpdate[]> {
+    const response = await this.request<TelegramGetUpdatesResponse>("getUpdates", {
+      offset: options.offset,
+      timeout: options.timeoutSeconds ?? 30,
+      limit: options.limit ?? 50,
+      allowed_updates: ["message"],
+    });
+
+    return response.result;
+  }
+
+  async sendMessage(input: { chatId: string; text: string; threadId?: string | null }): Promise<void> {
+    await this.request<TelegramSendMessageResponse>("sendMessage", {
+      chat_id: input.chatId,
+      text: input.text,
+      message_thread_id: input.threadId ? Number(input.threadId) : undefined,
+      disable_web_page_preview: true,
+    });
+  }
+
+  private async request<T extends { ok: boolean; description?: string }>(method: string, body: unknown): Promise<T> {
+    const response = await fetch(`${this.baseUrl}/${method}`, {
+      method: "POST",
+      headers: {
+        "content-type": "application/json",
+      },
+      body: JSON.stringify(body),
+    });
+
+    if (!response.ok) {
+      throw new Error(`telegram ${method} failed with HTTP ${response.status}`);
+    }
+
+    const payload = (await response.json()) as T;
+
+    if (!payload.ok) {
+      throw new Error(`telegram ${method} failed: ${payload.description ?? "unknown error"}`);
+    }
+
+    return payload;
+  }
+}

package/src/channels/telegram/TelegramPollingAdapter.ts

@@ -0,0 +1,123 @@
+import type { RuntimeKvRepository } from "../../db/repositories/RuntimeKvRepository";
+import { logger } from "../../logging/logger";
+import type { ChannelAdapter, InboundMessage, MessageHandler, OutboundMessage } from "../types";
+import { TelegramApi } from "./TelegramApi";
+import type { TelegramMessage, TelegramUpdate } from "./types";
+
+export type TelegramPollingAdapterOptions = {
+  api: TelegramApi;
+  runtimeKv: RuntimeKvRepository;
+  pollTimeoutSeconds?: number;
+  pollIntervalMs?: number;
+};
+
+const offsetKey = "telegram:update_offset";
+
+export class TelegramPollingAdapter implements ChannelAdapter {
+  readonly id = "telegram" as const;
+
+  private running = false;
+  private loopPromise: Promise<void> | null = null;
+  private botUserId: string | null = null;
+
+  constructor(private readonly options: TelegramPollingAdapterOptions) {}
+
+  async start(handler: MessageHandler): Promise<void> {
+    if (this.running) return;
+
+    const botUser = await this.options.api.getMe();
+    this.botUserId = String(botUser.id);
+
+    this.running = true;
+    this.loopPromise = this.poll(handler);
+    logger.info("telegram polling started", {
+      botUserId: this.botUserId,
+      username: botUser.username,
+    });
+  }
+
+  async stop(): Promise<void> {
+    if (!this.running) return;
+
+    this.running = false;
+    await this.loopPromise;
+    this.loopPromise = null;
+    logger.info("telegram polling stopped");
+  }
+
+  async send(message: OutboundMessage): Promise<void> {
+    if (message.channel !== "telegram") {
+      throw new Error(`unsupported channel for telegram adapter: ${message.channel}`);
+    }
+
+    await this.options.api.sendMessage({
+      chatId: message.chatId,
+      threadId: message.threadId,
+      text: message.text,
+    });
+  }
+
+  private async poll(handler: MessageHandler): Promise<void> {
+    while (this.running) {
+      try {
+        const offset = await this.loadOffset();
+        const updates = await this.options.api.getUpdates({
+          offset,
+          timeoutSeconds: this.options.pollTimeoutSeconds ?? 30,
+        });
+
+        for (const update of updates) {
+          await this.handleUpdate(update, handler);
+          await this.saveOffset(update.update_id + 1);
+        }
+      } catch (error) {
+        logger.error("telegram polling error", {
+          error: error instanceof Error ? error.message : String(error),
+        });
+        await sleep(this.options.pollIntervalMs ?? 1000);
+      }
+    }
+  }
+
+  private async handleUpdate(update: TelegramUpdate, handler: MessageHandler): Promise<void> {
+    const message = update.message;
+    if (!message?.text) return;
+    if (message.from?.is_bot) return;
+    if (this.botUserId && message.from?.id && String(message.from.id) === this.botUserId) return;
+
+    const normalized = normalizeTelegramMessage(update.update_id, message);
+    await handler(normalized);
+  }
+
+  private async loadOffset(): Promise<number | undefined> {
+    const value = await this.options.runtimeKv.get(offsetKey);
+    if (!value) return undefined;
+
+    const offset = Number(value);
+    return Number.isSafeInteger(offset) ? offset : undefined;
+  }
+
+  private async saveOffset(offset: number): Promise<void> {
+    await this.options.runtimeKv.set(offsetKey, String(offset));
+  }
+}
+
+function normalizeTelegramMessage(updateId: number, message: TelegramMessage): InboundMessage {
+  const senderName = [message.from?.first_name, message.from?.last_name].filter(Boolean).join(" ");
+
+  return {
+    id: String(updateId),
+    channel: "telegram",
+    chatId: String(message.chat.id),
+    threadId: message.message_thread_id ? String(message.message_thread_id) : null,
+    senderId: message.from ? String(message.from.id) : null,
+    senderName: senderName || message.from?.username || null,
+    text: message.text ?? "",
+    raw: message,
+    receivedAt: new Date(message.date * 1000),
+  };
+}
+
+function sleep(ms: number): Promise<void> {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}

package/src/channels/telegram/types.ts

@@ -0,0 +1,50 @@
+export type TelegramUser = {
+  id: number;
+  is_bot?: boolean;
+  first_name?: string;
+  last_name?: string;
+  username?: string;
+};
+
+export type TelegramChat = {
+  id: number;
+  type: "private" | "group" | "supergroup" | "channel";
+  title?: string;
+  username?: string;
+  first_name?: string;
+  last_name?: string;
+};
+
+export type TelegramMessage = {
+  message_id: number;
+  message_thread_id?: number;
+  from?: TelegramUser;
+  sender_chat?: TelegramChat;
+  chat: TelegramChat;
+  date: number;
+  text?: string;
+};
+
+export type TelegramUpdate = {
+  update_id: number;
+  message?: TelegramMessage;
+  edited_message?: TelegramMessage;
+};
+
+export type TelegramGetUpdatesResponse = {
+  ok: boolean;
+  result: TelegramUpdate[];
+  description?: string;
+};
+
+export type TelegramGetMeResponse = {
+  ok: boolean;
+  result: TelegramUser;
+  description?: string;
+};
+
+export type TelegramSendMessageResponse = {
+  ok: boolean;
+  result?: TelegramMessage;
+  description?: string;
+};

package/src/channels/types.ts

@@ -0,0 +1,29 @@
+export type ChannelId = "telegram";
+
+export type InboundMessage = {
+  id: string;
+  channel: ChannelId;
+  chatId: string;
+  threadId?: string | null;
+  senderId?: string | null;
+  senderName?: string | null;
+  text: string;
+  raw: unknown;
+  receivedAt: Date;
+};
+
+export type OutboundMessage = {
+  channel: ChannelId;
+  chatId: string;
+  threadId?: string | null;
+  text: string;
+};
+
+export type MessageHandler = (message: InboundMessage) => Promise<void>;
+
+export interface ChannelAdapter {
+  readonly id: ChannelId;
+  start(handler: MessageHandler): Promise<void>;
+  stop(): Promise<void>;
+  send(message: OutboundMessage): Promise<void>;
+}

package/src/cli/run.ts

@@ -0,0 +1,77 @@
+#!/usr/bin/env bun
+import { $ } from "bun";
+import { existsSync } from "node:fs";
+import { cp, mkdir } from "node:fs/promises";
+import { dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const args = process.argv.slice(2);
+const flags = new Set(args.filter((arg) => arg.startsWith("--")));
+const targetDirArg = args.find((arg) => !arg.startsWith("--"));
+const forceSetup = flags.has("--setup") || flags.has("--reconfigure");
+const skipInstall = flags.has("--skip-install");
+const skipMigrate = flags.has("--skip-migrate");
+const skipTypecheck = flags.has("--skip-typecheck");
+
+async function main(): Promise<void> {
+  if (targetDirArg) {
+    const targetDir = resolve(process.cwd(), targetDirArg);
+    await ensureProject(targetDir);
+    process.chdir(targetDir);
+  }
+
+  const { runSetup } = await import("./setup");
+
+  if (forceSetup || needsSetup(process.cwd())) {
+    await runSetup({ skipInstall, skipMigrate, skipTypecheck });
+  }
+
+  await $`bun run src/main.ts`;
+}
+
+async function ensureProject(targetDir: string): Promise<void> {
+  await mkdir(targetDir, { recursive: true });
+
+  if (existsSync(join(targetDir, "package.json"))) {
+    console.log(`[pigent] using existing project ${targetDir}`);
+    return;
+  }
+
+  const sourceRoot = resolve(dirname(fileURLToPath(import.meta.url)), "../..");
+  console.log(`[pigent] creating project ${targetDir}`);
+
+  await cp(sourceRoot, targetDir, {
+    recursive: true,
+    force: false,
+    filter: (source) => shouldCopy(sourceRoot, source),
+  });
+}
+
+function shouldCopy(sourceRoot: string, source: string): boolean {
+  const relative = source.slice(sourceRoot.length).replace(/^\/+/, "");
+  if (!relative) return true;
+
+  const blocked = [
+    ".git",
+    "node_modules",
+    "dist",
+    "coverage",
+    "pigent.db",
+    "pigent.db-shm",
+    "pigent.db-wal",
+    ".env",
+  ];
+
+  return !blocked.some((entry) => relative === entry || relative.startsWith(`${entry}/`));
+}
+
+function needsSetup(rootDir: string): boolean {
+  if (!existsSync(join(rootDir, ".env"))) return true;
+  if (!existsSync(join(rootDir, "pigent.db"))) return true;
+  return false;
+}
+
+main().catch((error) => {
+  console.error("[pigent] failed", error instanceof Error ? error.message : error);
+  process.exit(1);
+});