@fickydev/pigent 0.1.0

package/src/db/repositories/MessageRepository.ts

@@ -0,0 +1,45 @@
+import { nanoid } from "nanoid";
+import type { DbClient } from "../client";
+import { messages, type MessageRow } from "../schema";
+
+export type CreateMessageInput = {
+  agentId: string;
+  sessionId?: string | null;
+  channel: string;
+  direction: "inbound" | "outbound" | "internal";
+  senderId?: string | null;
+  chatId?: string | null;
+  threadId?: string | null;
+  content: string;
+  rawJson?: unknown;
+};
+
+export class MessageRepository {
+  constructor(private readonly db: DbClient) {}
+
+  async create(input: CreateMessageInput): Promise<MessageRow> {
+    const id = nanoid();
+    const now = Date.now();
+
+    await this.db.insert(messages).values({
+      id,
+      agentId: input.agentId,
+      sessionId: input.sessionId ?? null,
+      channel: input.channel,
+      direction: input.direction,
+      senderId: input.senderId ?? null,
+      chatId: input.chatId ?? null,
+      threadId: input.threadId ?? null,
+      content: input.content,
+      rawJson: input.rawJson === undefined ? null : JSON.stringify(input.rawJson),
+      createdAt: now,
+    });
+
+    const row = await this.db.query.messages.findFirst({
+      where: (table, { eq }) => eq(table.id, id),
+    });
+
+    if (!row) throw new Error(`failed to create message ${id}`);
+    return row;
+  }
+}

package/src/db/repositories/RuntimeKvRepository.ts

@@ -0,0 +1,27 @@
+import { eq } from "drizzle-orm";
+import type { DbClient } from "../client";
+import { runtimeKv } from "../schema";
+
+export class RuntimeKvRepository {
+  constructor(private readonly db: DbClient) {}
+
+  async get(key: string): Promise<string | null> {
+    const row = await this.db.query.runtimeKv.findFirst({
+      where: eq(runtimeKv.key, key),
+    });
+
+    return row?.value ?? null;
+  }
+
+  async set(key: string, value: string): Promise<void> {
+    const now = Date.now();
+
+    await this.db
+      .insert(runtimeKv)
+      .values({ key, value, updatedAt: now })
+      .onConflictDoUpdate({
+        target: runtimeKv.key,
+        set: { value, updatedAt: now },
+      });
+  }
+}

package/src/db/repositories/SessionRepository.ts

@@ -0,0 +1,65 @@
+import { and, eq, isNull } from "drizzle-orm";
+import { nanoid } from "nanoid";
+import type { DbClient } from "../client";
+import { agentSessions, type AgentSessionRow } from "../schema";
+
+export type SessionKey = {
+  agentId: string;
+  channel: string;
+  chatId: string;
+  threadId?: string | null;
+  userId?: string | null;
+};
+
+export class SessionRepository {
+  constructor(private readonly db: DbClient) {}
+
+  async getOrCreate(key: SessionKey): Promise<AgentSessionRow> {
+    const existing = await this.findByKey(key);
+    if (existing) return existing;
+
+    const now = Date.now();
+    const id = nanoid();
+
+    await this.db.insert(agentSessions).values({
+      id,
+      agentId: key.agentId,
+      channel: key.channel,
+      chatId: key.chatId,
+      threadId: key.threadId ?? null,
+      userId: key.userId ?? null,
+      createdAt: now,
+      updatedAt: now,
+    });
+
+    const created = await this.findById(id);
+    if (!created) throw new Error(`failed to create session ${id}`);
+
+    return created;
+  }
+
+  async findById(id: string): Promise<AgentSessionRow | null> {
+    const row = await this.db.query.agentSessions.findFirst({
+      where: eq(agentSessions.id, id),
+    });
+
+    return row ?? null;
+  }
+
+  private async findByKey(key: SessionKey): Promise<AgentSessionRow | null> {
+    const threadPredicate = key.threadId
+      ? eq(agentSessions.threadId, key.threadId)
+      : isNull(agentSessions.threadId);
+
+    const row = await this.db.query.agentSessions.findFirst({
+      where: and(
+        eq(agentSessions.agentId, key.agentId),
+        eq(agentSessions.channel, key.channel),
+        eq(agentSessions.chatId, key.chatId),
+        threadPredicate,
+      ),
+    });
+
+    return row ?? null;
+  }
+}

package/src/db/repositories/TelegramRepository.ts

@@ -0,0 +1,98 @@
+import { and, eq } from "drizzle-orm";
+import { nanoid } from "nanoid";
+import type { TelegramChatConfig } from "../../config/schemas";
+import type { InboundMessage } from "../../channels/types";
+import type { DbClient } from "../client";
+import { telegramChatAgents, telegramChats, type TelegramChatRow } from "../schema";
+
+export class TelegramRepository {
+  constructor(private readonly db: DbClient) {}
+
+  async upsertConfiguredChat(chat: TelegramChatConfig): Promise<void> {
+    const now = Date.now();
+
+    await this.db
+      .insert(telegramChats)
+      .values({
+        chatId: chat.chatId,
+        title: chat.title,
+        defaultAgentId: chat.defaultAgent,
+        instructions: chat.instructions,
+        enabled: chat.enabled,
+        createdAt: now,
+        updatedAt: now,
+      })
+      .onConflictDoUpdate({
+        target: telegramChats.chatId,
+        set: {
+          title: chat.title,
+          defaultAgentId: chat.defaultAgent,
+          instructions: chat.instructions,
+          enabled: chat.enabled,
+          updatedAt: now,
+        },
+      });
+
+    const allowedAgents = chat.allowedAgents.length > 0 ? chat.allowedAgents : [chat.defaultAgent];
+
+    for (const agentId of allowedAgents) {
+      await this.db
+        .insert(telegramChatAgents)
+        .values({
+          id: nanoid(),
+          chatId: chat.chatId,
+          agentId,
+          enabled: true,
+          customInstructions: "",
+          createdAt: now,
+          updatedAt: now,
+        })
+        .onConflictDoUpdate({
+          target: [telegramChatAgents.chatId, telegramChatAgents.agentId],
+          set: {
+            enabled: true,
+            updatedAt: now,
+          },
+        });
+    }
+  }
+
+  async autoConfigureChat(message: InboundMessage, defaultAgentId: string): Promise<void> {
+    const existing = await this.findChat(message.chatId);
+    if (existing) return;
+
+    const raw = message.raw as { chat?: { title?: string; username?: string; first_name?: string; last_name?: string } } | null;
+    const title = raw?.chat
+      ? raw.chat.title ?? [raw.chat.first_name, raw.chat.last_name].filter(Boolean).join(" ") ?? raw.chat.username
+      : undefined;
+
+    await this.upsertConfiguredChat({
+      chatId: message.chatId,
+      title: title || undefined,
+      defaultAgent: defaultAgentId,
+      allowedAgents: [defaultAgentId],
+      instructions: "",
+      enabled: true,
+    });
+  }
+
+  async findChat(chatId: string): Promise<TelegramChatRow | null> {
+    const row = await this.db.query.telegramChats.findFirst({
+      where: eq(telegramChats.chatId, chatId),
+    });
+
+    return row ?? null;
+  }
+
+  async isAgentAllowed(chatId: string, agentId: string): Promise<boolean> {
+    const row = await this.db.query.telegramChatAgents.findFirst({
+      where: and(
+        eq(telegramChatAgents.chatId, chatId),
+        eq(telegramChatAgents.agentId, agentId),
+        eq(telegramChatAgents.enabled, true),
+      ),
+    });
+
+    return Boolean(row);
+  }
+}

package/src/db/repositories/index.ts

@@ -0,0 +1,18 @@
+import { db } from "../client";
+import { AgentRepository } from "./AgentRepository";
+import { MessageRepository } from "./MessageRepository";
+import { RuntimeKvRepository } from "./RuntimeKvRepository";
+import { SessionRepository } from "./SessionRepository";
+import { TelegramRepository } from "./TelegramRepository";
+
+export type Repositories = ReturnType<typeof createRepositories>;
+
+export function createRepositories(dbClient = db) {
+  return {
+    agents: new AgentRepository(dbClient),
+    messages: new MessageRepository(dbClient),
+    runtimeKv: new RuntimeKvRepository(dbClient),
+    sessions: new SessionRepository(dbClient),
+    telegram: new TelegramRepository(dbClient),
+  };
+}

package/src/db/schema.ts

@@ -0,0 +1,106 @@
+import { integer, sqliteTable, text, uniqueIndex } from "drizzle-orm/sqlite-core";
+
+export const agents = sqliteTable("agents", {
+  id: text("id").primaryKey(),
+  name: text("name").notNull(),
+  profile: text("profile").notNull(),
+  workspace: text("workspace").notNull(),
+  configJson: text("config_json").notNull(),
+  systemPrompt: text("system_prompt").notNull().default(""),
+  createdAt: integer("created_at").notNull(),
+  updatedAt: integer("updated_at").notNull(),
+});
+
+export const telegramChats = sqliteTable("telegram_chats", {
+  chatId: text("chat_id").primaryKey(),
+  title: text("title"),
+  defaultAgentId: text("default_agent_id"),
+  instructions: text("instructions").notNull().default(""),
+  enabled: integer("enabled", { mode: "boolean" }).notNull().default(true),
+  createdAt: integer("created_at").notNull(),
+  updatedAt: integer("updated_at").notNull(),
+});
+
+export const telegramChatAgents = sqliteTable(
+  "telegram_chat_agents",
+  {
+    id: text("id").primaryKey(),
+    chatId: text("chat_id").notNull(),
+    agentId: text("agent_id").notNull(),
+    enabled: integer("enabled", { mode: "boolean" }).notNull().default(true),
+    customInstructions: text("custom_instructions").notNull().default(""),
+    createdAt: integer("created_at").notNull(),
+    updatedAt: integer("updated_at").notNull(),
+  },
+  (table) => ({
+    chatAgentUnique: uniqueIndex("telegram_chat_agents_chat_agent_unique").on(table.chatId, table.agentId),
+  }),
+);
+
+export const agentSessions = sqliteTable(
+  "agent_sessions",
+  {
+    id: text("id").primaryKey(),
+    agentId: text("agent_id").notNull(),
+    channel: text("channel").notNull(),
+    chatId: text("chat_id").notNull(),
+    threadId: text("thread_id"),
+    userId: text("user_id"),
+    piSessionId: text("pi_session_id"),
+    instructionsHash: text("instructions_hash"),
+    createdAt: integer("created_at").notNull(),
+    updatedAt: integer("updated_at").notNull(),
+  },
+  (table) => ({
+    sessionKeyUnique: uniqueIndex("agent_sessions_key_unique").on(
+      table.agentId,
+      table.channel,
+      table.chatId,
+      table.threadId,
+    ),
+  }),
+);
+
+export const messages = sqliteTable("messages", {
+  id: text("id").primaryKey(),
+  agentId: text("agent_id").notNull(),
+  sessionId: text("session_id"),
+  channel: text("channel").notNull(),
+  direction: text("direction", { enum: ["inbound", "outbound", "internal"] }).notNull(),
+  senderId: text("sender_id"),
+  chatId: text("chat_id"),
+  threadId: text("thread_id"),
+  content: text("content").notNull(),
+  rawJson: text("raw_json"),
+  createdAt: integer("created_at").notNull(),
+});
+
+export const heartbeats = sqliteTable("heartbeats", {
+  id: text("id").primaryKey(),
+  agentId: text("agent_id").notNull(),
+  sessionId: text("session_id"),
+  status: text("status", { enum: ["pending", "running", "noop", "notified", "failed"] }).notNull(),
+  prompt: text("prompt").notNull(),
+  result: text("result"),
+  error: text("error"),
+  startedAt: integer("started_at"),
+  finishedAt: integer("finished_at"),
+  createdAt: integer("created_at").notNull(),
+});
+
+export const runtimeKv = sqliteTable("runtime_kv", {
+  key: text("key").primaryKey(),
+  value: text("value").notNull(),
+  updatedAt: integer("updated_at").notNull(),
+});
+
+export type AgentRow = typeof agents.$inferSelect;
+export type NewAgentRow = typeof agents.$inferInsert;
+export type TelegramChatRow = typeof telegramChats.$inferSelect;
+export type NewTelegramChatRow = typeof telegramChats.$inferInsert;
+export type AgentSessionRow = typeof agentSessions.$inferSelect;
+export type NewAgentSessionRow = typeof agentSessions.$inferInsert;
+export type MessageRow = typeof messages.$inferSelect;
+export type NewMessageRow = typeof messages.$inferInsert;
+export type HeartbeatRow = typeof heartbeats.$inferSelect;
+export type NewHeartbeatRow = typeof heartbeats.$inferInsert;

package/src/logging/logger.ts

@@ -0,0 +1,45 @@
+export type LogLevel = "debug" | "info" | "warn" | "error";
+
+type LogFields = Record<string, unknown>;
+
+const levels: Record<LogLevel, number> = {
+  debug: 10,
+  info: 20,
+  warn: 30,
+  error: 40,
+};
+
+const configuredLevel = (process.env.LOG_LEVEL ?? "info") as LogLevel;
+const minLevel = levels[configuredLevel] ?? levels.info;
+
+function writeLog(level: LogLevel, message: string, fields?: LogFields): void {
+  if (levels[level] < minLevel) return;
+
+  const entry = {
+    time: new Date().toISOString(),
+    level,
+    message,
+    ...fields,
+  };
+
+  const line = JSON.stringify(entry);
+
+  if (level === "error") {
+    console.error(line);
+    return;
+  }
+
+  if (level === "warn") {
+    console.warn(line);
+    return;
+  }
+
+  console.log(line);
+}
+
+export const logger = {
+  debug: (message: string, fields?: LogFields) => writeLog("debug", message, fields),
+  info: (message: string, fields?: LogFields) => writeLog("info", message, fields),
+  warn: (message: string, fields?: LogFields) => writeLog("warn", message, fields),
+  error: (message: string, fields?: LogFields) => writeLog("error", message, fields),
+};

package/src/main.ts

@@ -0,0 +1,37 @@
+import { AgentDaemon } from "./daemon/AgentDaemon";
+import { logger } from "./logging/logger";
+
+const daemon = await AgentDaemon.create();
+
+let stopping = false;
+
+async function shutdown(signal: string): Promise<void> {
+  if (stopping) return;
+  stopping = true;
+
+  logger.info("shutdown requested", { signal });
+
+  try {
+    await daemon.stop();
+    process.exit(0);
+  } catch (error) {
+    logger.error("shutdown failed", {
+      error: error instanceof Error ? error.message : String(error),
+    });
+    process.exit(1);
+  }
+}
+
+process.on("SIGINT", () => void shutdown("SIGINT"));
+process.on("SIGTERM", () => void shutdown("SIGTERM"));
+
+try {
+  logger.info("pigent starting");
+  await daemon.start();
+  logger.info("pigent ready");
+} catch (error) {
+  logger.error("pigent failed to start", {
+    error: error instanceof Error ? error.message : String(error),
+  });
+  process.exit(1);
+}

package/src/pi/PiAgentRunner.ts

@@ -0,0 +1,73 @@
+import {
+  AuthStorage,
+  createAgentSession,
+  DefaultResourceLoader,
+  ModelRegistry,
+  getAgentDir,
+  SessionManager,
+  SettingsManager,
+} from "@earendil-works/pi-coding-agent";
+import { mkdir } from "node:fs/promises";
+import { resolve } from "node:path";
+import type { LoadedAgentConfig, ProfileConfig } from "../config/schemas";
+
+export type PiAgentRunInput = {
+  agent: LoadedAgentConfig;
+  profile: ProfileConfig | null;
+  prompt: string;
+};
+
+export class PiAgentRunner {
+  async run(input: PiAgentRunInput): Promise<string> {
+    const workspace = resolve(input.agent.workspace);
+    await mkdir(workspace, { recursive: true });
+
+    const systemPrompt = composeSystemPrompt(input.agent, input.profile);
+    const settingsManager = SettingsManager.inMemory({
+      compaction: { enabled: false },
+    });
+    const agentDir = getAgentDir();
+    const resourceLoader = new DefaultResourceLoader({
+      cwd: workspace,
+      agentDir,
+      settingsManager,
+      systemPromptOverride: () => systemPrompt,
+    });
+    await resourceLoader.reload();
+
+    const authStorage = AuthStorage.create();
+    const modelRegistry = ModelRegistry.create(authStorage);
+    const { session } = await createAgentSession({
+      cwd: workspace,
+      authStorage,
+      modelRegistry,
+      resourceLoader,
+      sessionManager: SessionManager.create(workspace),
+      settingsManager,
+      agentDir,
+      tools: [],
+    });
+
+    let response = "";
+    session.subscribe((event) => {
+      if (event.type === "message_update" && event.assistantMessageEvent.type === "text_delta") {
+        response += event.assistantMessageEvent.delta;
+      }
+    });
+
+    await session.prompt(input.prompt);
+
+    return response.trim() || "(no response)";
+  }
+}
+
+function composeSystemPrompt(agent: LoadedAgentConfig, profile: ProfileConfig | null): string {
+  return [
+    profile?.instructions,
+    agent.systemPrompt,
+    "You are running inside Pigent, a channel-orchestrated autonomous agent daemon.",
+    "Do not reveal secrets. Keep responses suitable for external chat.",
+  ]
+    .filter(Boolean)
+    .join("\n\n");
+}

package/tsconfig.json

@@ -0,0 +1,17 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ESNext",
+    "moduleResolution": "Bundler",
+    "lib": ["ES2022"],
+    "types": ["bun-types"],
+    "strict": true,
+    "skipLibCheck": true,
+    "noEmit": true,
+    "allowImportingTsExtensions": true,
+    "esModuleInterop": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true
+  },
+  "include": ["src/**/*.ts", "drizzle.config.ts"]
+}