@fickydev/pigent 0.1.0

package/src/cli/setup.ts

@@ -0,0 +1,261 @@
+import { existsSync } from "node:fs";
+import { copyFile, mkdir, readFile, writeFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import { $ } from "bun";
+import YAML from "yaml";
+
+const rootDir = process.cwd();
+const envPath = join(rootDir, ".env");
+const envExamplePath = join(rootDir, ".env.example");
+const pigentConfigPath = join(rootDir, "pigent.yaml");
+
+export type SetupOptions = {
+  skipInstall?: boolean;
+  skipMigrate?: boolean;
+  skipTypecheck?: boolean;
+};
+
+export async function runSetup(options: SetupOptions = {}): Promise<void> {
+  const skipInstall = options.skipInstall ?? false;
+  const skipMigrate = options.skipMigrate ?? false;
+  const skipTypecheck = options.skipTypecheck ?? false;
+
+  banner();
+
+  const mode = select("Setup mode", ["quick", "custom"], "quick");
+  const isCustom = mode === "custom";
+
+  await ensureEnvFile();
+  await configureEnvironment(isCustom);
+  await configureTelegramChat(isCustom);
+
+  if (!skipInstall && confirm("Install dependencies?", true)) {
+    await runStep("Install dependencies", async () => {
+      await $`bun install`;
+    });
+  }
+
+  if (!skipMigrate && confirm("Apply database migrations?", true)) {
+    await runStep("Apply database migrations", async () => {
+      await $`bun run db:migrate`;
+    });
+  }
+
+  if (!skipTypecheck && confirm("Run typecheck?", true)) {
+    await runStep("Typecheck", async () => {
+      await $`bun run typecheck`;
+    });
+  }
+
+  summary();
+}
+
+function banner(): void {
+  console.log("\nPigent interactive setup");
+  console.log("------------------------");
+}
+
+async function ensureEnvFile(): Promise<void> {
+  if (existsSync(envPath)) {
+    log(".env exists");
+    return;
+  }
+
+  await copyFile(envExamplePath, envPath);
+  log("Created .env from .env.example");
+}
+
+async function configureEnvironment(isCustom: boolean): Promise<void> {
+  let env = await readFile(envPath, "utf8");
+
+  if (isCustom || !getEnvValue(env, "DATABASE_URL")) {
+    const databaseUrl = input("Database URL", getEnvValue(env, "DATABASE_URL") ?? "file:./pigent.db");
+    env = setEnvValue(env, "DATABASE_URL", databaseUrl);
+  }
+
+  const currentToken = getEnvValue(env, "TELEGRAM_BOT_TOKEN");
+  if (currentToken) {
+    log("TELEGRAM_BOT_TOKEN already set");
+    if (confirm("Replace Telegram bot token?", false)) {
+      const nextToken = input("Telegram bot token", currentToken);
+      env = setEnvValue(env, "TELEGRAM_BOT_TOKEN", nextToken);
+    }
+  } else if (confirm("Configure Telegram bot token now?", true)) {
+    const token = input("Telegram bot token", "");
+    if (token) {
+      env = setEnvValue(env, "TELEGRAM_BOT_TOKEN", token);
+    } else {
+      log("Telegram token skipped; Telegram polling disabled until TELEGRAM_BOT_TOKEN is set");
+    }
+  }
+
+  if (confirm("Auto-configure new Telegram chats?", getEnvValue(env, "PIGENT_AUTO_SETUP_CHATS") === "1")) {
+    env = setEnvValue(env, "PIGENT_AUTO_SETUP_CHATS", "1");
+    env = setEnvValue(
+      env,
+      "PIGENT_AUTO_SETUP_DEFAULT_AGENT",
+      input("Auto-setup default agent", getEnvValue(env, "PIGENT_AUTO_SETUP_DEFAULT_AGENT") ?? "coder"),
+    );
+  } else {
+    env = setEnvValue(env, "PIGENT_AUTO_SETUP_CHATS", "0");
+  }
+
+  if (isCustom) {
+    env = setEnvValue(env, "LOG_LEVEL", select("Log level", ["debug", "info", "warn", "error"], getEnvValue(env, "LOG_LEVEL") ?? "info"));
+    env = setEnvValue(
+      env,
+      "TELEGRAM_POLL_TIMEOUT_SECONDS",
+      input("Telegram poll timeout seconds", getEnvValue(env, "TELEGRAM_POLL_TIMEOUT_SECONDS") ?? "30"),
+    );
+    env = setEnvValue(
+      env,
+      "TELEGRAM_POLL_INTERVAL_MS",
+      input("Telegram poll error backoff ms", getEnvValue(env, "TELEGRAM_POLL_INTERVAL_MS") ?? "1000"),
+    );
+  }
+
+  await writeFile(envPath, env);
+  log("Environment configured");
+}
+
+async function configureTelegramChat(isCustom: boolean): Promise<void> {
+  if (!existsSync(pigentConfigPath)) {
+    await writeFile(pigentConfigPath, "telegramChats: []\n");
+    log("Created pigent.yaml");
+  }
+
+  if (!confirm("Configure Telegram chat routing now? Requires chat id.", false)) {
+    log("Telegram chat config skipped");
+    return;
+  }
+
+  const chatId = input("Telegram chat id", "");
+  if (!chatId) {
+    log("No chat id entered; skipped chat config");
+    return;
+  }
+
+  const title = input("Chat title", "");
+  const defaultAgent = input("Default agent", "coder") || "coder";
+  const allowedAgentsInput = input("Allowed agents, comma-separated", defaultAgent);
+  const instructions = isCustom ? inputMultiline("Chat instructions", "") : "";
+  const allowedAgents = allowedAgentsInput
+    .split(",")
+    .map((agent) => agent.trim())
+    .filter(Boolean);
+
+  const content = await readFile(pigentConfigPath, "utf8");
+  const parsed = YAML.parse(content || "telegramChats: []\n") as { telegramChats?: Array<Record<string, unknown>> } | null;
+  const root = parsed ?? {};
+  const chats = Array.isArray(root.telegramChats) ? root.telegramChats : [];
+  const existingIndex = chats.findIndex((chat) => chat.chatId === chatId);
+  const nextChat = {
+    chatId,
+    title: title || undefined,
+    defaultAgent,
+    allowedAgents: allowedAgents.length > 0 ? allowedAgents : [defaultAgent],
+    instructions,
+  };
+
+  if (existingIndex >= 0) {
+    chats[existingIndex] = {
+      ...chats[existingIndex],
+      ...nextChat,
+    };
+  } else {
+    chats.push(nextChat);
+  }
+
+  root.telegramChats = chats;
+  await mkdir(dirname(pigentConfigPath), { recursive: true });
+  await writeFile(pigentConfigPath, YAML.stringify(root));
+  log(`Configured Telegram chat ${chatId}`);
+}
+
+async function runStep(name: string, step: () => Promise<void>): Promise<void> {
+  log(name);
+  await step();
+}
+
+function input(label: string, defaultValue: string): string {
+  const suffix = defaultValue ? ` [${defaultValue}]` : "";
+  const value = prompt(`${label}${suffix}:`)?.trim();
+  return value || defaultValue;
+}
+
+function inputMultiline(label: string, defaultValue: string): string {
+  console.log(`${label} (finish with a single . line):`);
+  const lines: string[] = [];
+
+  while (true) {
+    const value = prompt(">") ?? "";
+    if (value === ".") break;
+    lines.push(value);
+  }
+
+  const result = lines.join("\n").trim();
+  return result || defaultValue;
+}
+
+function confirm(label: string, defaultValue: boolean): boolean {
+  const suffix = defaultValue ? "Y/n" : "y/N";
+  const value = prompt(`${label} [${suffix}]`)?.trim().toLowerCase();
+
+  if (!value) return defaultValue;
+  return value === "y" || value === "yes";
+}
+
+function select<T extends string>(label: string, options: T[], defaultValue: T): T {
+  const value = input(`${label} (${options.join("/")})`, defaultValue);
+  return options.includes(value as T) ? (value as T) : defaultValue;
+}
+
+function getEnvValue(content: string, key: string): string | null {
+  const line = content
+    .split("\n")
+    .find((candidate) => candidate.trim().startsWith(`${key}=`));
+
+  if (!line) return null;
+
+  const value = line.slice(line.indexOf("=") + 1).trim();
+  return value || null;
+}
+
+function setEnvValue(content: string, key: string, value: string): string {
+  const lines = content.split("\n");
+  const index = lines.findIndex((line) => line.trim().startsWith(`${key}=`));
+  const nextLine = `${key}=${value}`;
+
+  if (index >= 0) {
+    lines[index] = nextLine;
+  } else {
+    lines.push(nextLine);
+  }
+
+  return lines.join("\n");
+}
+
+function summary(): void {
+  console.log("\nSetup complete");
+  console.log("--------------");
+  console.log("Start daemon: bun run start");
+  console.log("Dev mode:     bun run dev");
+  console.log("Typecheck:    bun run typecheck");
+}
+
+function log(message: string): void {
+  console.log(`[setup] ${message}`);
+}
+
+if (import.meta.main) {
+  const flags = new Set(process.argv.slice(2));
+
+  runSetup({
+    skipInstall: flags.has("--skip-install"),
+    skipMigrate: flags.has("--skip-migrate"),
+    skipTypecheck: flags.has("--skip-typecheck"),
+  }).catch((error) => {
+    console.error("[setup] failed", error instanceof Error ? error.message : error);
+    process.exit(1);
+  });
+}

package/src/config/loadConfig.ts

@@ -0,0 +1,115 @@
+import { readdir, readFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { join, resolve } from "node:path";
+import YAML from "yaml";
+import {
+  AgentConfigSchema,
+  type LoadedAgentConfig,
+  type LoadedConfig,
+  ProfileConfigSchema,
+  RootConfigSchema,
+} from "./schemas";
+
+export type LoadConfigOptions = {
+  rootDir?: string;
+};
+
+async function readYamlFile(path: string): Promise<unknown> {
+  const content = await readFile(path, "utf8");
+  return YAML.parse(content) as unknown;
+}
+
+async function readOptionalTextFile(path: string): Promise<string> {
+  try {
+    return await readFile(path, "utf8");
+  } catch (error) {
+    if (error && typeof error === "object" && "code" in error && error.code === "ENOENT") {
+      return "";
+    }
+
+    throw error;
+  }
+}
+
+async function loadAgents(rootDir: string): Promise<LoadedAgentConfig[]> {
+  const agentsDir = join(rootDir, "agents");
+  const entries = await readdir(agentsDir, { withFileTypes: true }).catch(() => []);
+  const agents: LoadedAgentConfig[] = [];
+
+  for (const entry of entries) {
+    if (!entry.isDirectory()) continue;
+
+    const baseDir = join(agentsDir, entry.name);
+    const configPath = join(baseDir, "agent.yaml");
+    const parsed = await readYamlFile(configPath);
+    const agent = AgentConfigSchema.parse(parsed);
+    const systemPromptPath = agent.systemPromptFile ? resolve(baseDir, agent.systemPromptFile) : join(baseDir, "SYSTEM.md");
+    const systemPrompt = await readOptionalTextFile(systemPromptPath);
+
+    agents.push({
+      ...agent,
+      workspace: expandPath(agent.workspace),
+      baseDir,
+      systemPrompt,
+    });
+  }
+
+  return agents;
+}
+
+async function loadProfiles(rootDir: string) {
+  const profilesDir = join(rootDir, "profiles");
+  const entries = await readdir(profilesDir, { withFileTypes: true }).catch(() => []);
+  const profiles = [];
+
+  for (const entry of entries) {
+    if (!entry.isFile()) continue;
+    if (!entry.name.endsWith(".yaml") && !entry.name.endsWith(".yml")) continue;
+
+    const configPath = join(profilesDir, entry.name);
+    const parsed = await readYamlFile(configPath);
+    profiles.push(ProfileConfigSchema.parse(parsed));
+  }
+
+  return profiles;
+}
+
+async function loadRootConfig(rootDir: string) {
+  const candidates = ["pigent.yaml", "pigent.yml"];
+
+  for (const candidate of candidates) {
+    try {
+      const parsed = await readYamlFile(join(rootDir, candidate));
+      return RootConfigSchema.parse(parsed);
+    } catch (error) {
+      if (error && typeof error === "object" && "code" in error && error.code === "ENOENT") {
+        continue;
+      }
+
+      throw error;
+    }
+  }
+
+  return RootConfigSchema.parse({});
+}
+
+function expandPath(path: string): string {
+  if (path === "~") return homedir();
+  if (path.startsWith("~/")) return join(homedir(), path.slice(2));
+  return path;
+}
+
+export async function loadConfig(options: LoadConfigOptions = {}): Promise<LoadedConfig> {
+  const rootDir = resolve(options.rootDir ?? process.cwd());
+  const [agents, profiles, rootConfig] = await Promise.all([
+    loadAgents(rootDir),
+    loadProfiles(rootDir),
+    loadRootConfig(rootDir),
+  ]);
+
+  return {
+    agents,
+    profiles,
+    telegramChats: rootConfig.telegramChats,
+  };
+}

package/src/config/schemas.ts

@@ -0,0 +1,92 @@
+import { z } from "zod";
+
+const relativeOrAbsolutePathSchema = z.string().min(1);
+
+export const PermissionConfigSchema = z.object({
+  canRunShell: z.boolean().default(false),
+  canEditFiles: z.boolean().default(false),
+  allowedPaths: z.array(z.string()).default([]),
+  blockedTools: z.array(z.string()).default([]),
+});
+
+export const HeartbeatConfigSchema = z.object({
+  enabled: z.boolean().default(false),
+  intervalMs: z.number().int().positive().default(600_000),
+  prompt: z.string().min(1).default("If no useful action is needed, reply exactly: NOOP."),
+});
+
+export const AgentTelegramChannelConfigSchema = z.object({
+  enabled: z.boolean().default(false),
+});
+
+export const AgentChannelsConfigSchema = z.object({
+  telegram: AgentTelegramChannelConfigSchema.default({ enabled: false }),
+});
+
+export const AgentConfigSchema = z.object({
+  id: z.string().min(1).regex(/^[a-zA-Z0-9_-]+$/),
+  name: z.string().min(1),
+  profile: z.string().min(1),
+  workspace: relativeOrAbsolutePathSchema,
+  systemPromptFile: relativeOrAbsolutePathSchema.optional(),
+  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,
+    allowedPaths: [],
+    blockedTools: [],
+  }),
+});
+
+export const ProfileConfigSchema = z.object({
+  id: z.string().min(1).regex(/^[a-zA-Z0-9_-]+$/),
+  name: z.string().min(1),
+  model: z.string().min(1).nullable().default(null),
+  instructions: z.string().default(""),
+  defaultSkills: z.array(z.string()).default([]),
+  defaultExtensions: z.array(z.string()).default([]),
+  permissions: PermissionConfigSchema.default({
+    canRunShell: false,
+    canEditFiles: false,
+    allowedPaths: [],
+    blockedTools: [],
+  }),
+});
+
+export const TelegramChatConfigSchema = z.object({
+  chatId: z.string().min(1),
+  title: z.string().optional(),
+  defaultAgent: z.string().min(1),
+  allowedAgents: z.array(z.string()).default([]),
+  instructions: z.string().default(""),
+  enabled: z.boolean().default(true),
+});
+
+export const RootConfigSchema = z.object({
+  telegramChats: z.array(TelegramChatConfigSchema).default([]),
+});
+
+export type PermissionConfig = z.infer<typeof PermissionConfigSchema>;
+export type HeartbeatConfig = z.infer<typeof HeartbeatConfigSchema>;
+export type AgentConfig = z.infer<typeof AgentConfigSchema>;
+export type ProfileConfig = z.infer<typeof ProfileConfigSchema>;
+export type TelegramChatConfig = z.infer<typeof TelegramChatConfigSchema>;
+export type RootConfig = z.infer<typeof RootConfigSchema>;
+
+export type LoadedAgentConfig = AgentConfig & {
+  baseDir: string;
+  systemPrompt: string;
+};
+
+export type LoadedConfig = {
+  agents: LoadedAgentConfig[];
+  profiles: ProfileConfig[];
+  telegramChats: TelegramChatConfig[];
+};

package/src/daemon/AgentDaemon.ts

@@ -0,0 +1,161 @@
+import { AgentRunner } from "../agents/AgentRunner";
+import { BotCommandHandler } from "../agents/BotCommandHandler";
+import { MessageRouter } from "../agents/MessageRouter";
+import { TelegramApi } from "../channels/telegram/TelegramApi";
+import { TelegramPollingAdapter } from "../channels/telegram/TelegramPollingAdapter";
+import type { ChannelAdapter, InboundMessage, OutboundMessage } from "../channels/types";
+import { loadConfig } from "../config/loadConfig";
+import type { LoadedConfig } from "../config/schemas";
+import { createRepositories, type Repositories } from "../db/repositories";
+import { logger } from "../logging/logger";
+
+export class AgentDaemon {
+  private running = false;
+  private readonly adapters: ChannelAdapter[];
+  private readonly commands: BotCommandHandler;
+  private readonly router: MessageRouter;
+  private readonly runner: AgentRunner;
+
+  private constructor(
+    private readonly config: LoadedConfig,
+    private readonly repositories: Repositories,
+  ) {
+    this.adapters = createAdapters(repositories);
+    this.commands = new BotCommandHandler(config, repositories);
+    this.router = new MessageRouter(repositories);
+    this.runner = new AgentRunner(config, repositories);
+  }
+
+  static async create(): Promise<AgentDaemon> {
+    const config = await loadConfig();
+    return new AgentDaemon(config, createRepositories());
+  }
+
+  async start(): Promise<void> {
+    if (this.running) return;
+
+    await this.syncConfiguredState();
+
+    this.running = true;
+
+    for (const adapter of this.adapters) {
+      await adapter.start((message) => this.handleInboundMessage(message));
+    }
+
+    logger.info("pigent daemon started", {
+      agents: this.config.agents.length,
+      profiles: this.config.profiles.length,
+      telegramChats: this.config.telegramChats.length,
+      adapters: this.adapters.map((adapter) => adapter.id),
+    });
+  }
+
+  async stop(): Promise<void> {
+    if (!this.running) return;
+
+    this.running = false;
+
+    for (const adapter of this.adapters) {
+      await adapter.stop();
+    }
+
+    logger.info("pigent daemon stopped");
+  }
+
+  private async syncConfiguredState(): Promise<void> {
+    for (const agent of this.config.agents) {
+      await this.repositories.agents.upsertLoadedAgent(agent);
+    }
+
+    for (const chat of this.config.telegramChats) {
+      await this.repositories.telegram.upsertConfiguredChat(chat);
+    }
+  }
+
+  private async handleInboundMessage(message: InboundMessage): Promise<void> {
+    logger.info("inbound message received", {
+      channel: message.channel,
+      chatId: message.chatId,
+      threadId: message.threadId,
+      senderId: message.senderId,
+      textLength: message.text.length,
+    });
+
+    await this.autoConfigureChat(message);
+
+    const command = await this.commands.handle(message);
+
+    if (command.handled) {
+      await this.send({
+        channel: message.channel,
+        chatId: message.chatId,
+        threadId: message.threadId,
+        text: command.text,
+      });
+      return;
+    }
+
+    const route = await this.router.route(message);
+
+    if (!route.ok) {
+      await this.send({
+        channel: message.channel,
+        chatId: message.chatId,
+        threadId: message.threadId,
+        text: route.message,
+      });
+      return;
+    }
+
+    const response = await this.runner.run({
+      agentId: route.agentId,
+      text: route.text,
+      message,
+    });
+
+    await this.send({
+      channel: message.channel,
+      chatId: message.chatId,
+      threadId: message.threadId,
+      text: response,
+    });
+  }
+
+  private async autoConfigureChat(message: InboundMessage): Promise<void> {
+    if (message.channel !== "telegram") return;
+    if (process.env.PIGENT_AUTO_SETUP_CHATS !== "1") return;
+
+    const defaultAgentId = process.env.PIGENT_AUTO_SETUP_DEFAULT_AGENT ?? this.config.agents[0]?.id;
+    if (!defaultAgentId) return;
+
+    await this.repositories.telegram.autoConfigureChat(message, defaultAgentId);
+  }
+
+  private async send(message: OutboundMessage): Promise<void> {
+    const adapter = this.adapters.find((candidate) => candidate.id === message.channel);
+    if (!adapter) {
+      logger.warn("no adapter available for outbound message", { channel: message.channel });
+      return;
+    }
+
+    await adapter.send(message);
+  }
+}
+
+function createAdapters(repositories: Repositories): ChannelAdapter[] {
+  const adapters: ChannelAdapter[] = [];
+  const telegramToken = process.env.TELEGRAM_BOT_TOKEN;
+
+  if (telegramToken) {
+    adapters.push(
+      new TelegramPollingAdapter({
+        api: new TelegramApi({ token: telegramToken }),
+        runtimeKv: repositories.runtimeKv,
+        pollTimeoutSeconds: Number(process.env.TELEGRAM_POLL_TIMEOUT_SECONDS ?? 30),
+        pollIntervalMs: Number(process.env.TELEGRAM_POLL_INTERVAL_MS ?? 1000),
+      }),
+    );
+  }
+
+  return adapters;
+}

package/src/db/client.ts

@@ -0,0 +1,23 @@
+import { mkdirSync } from "node:fs";
+import { dirname, resolve } from "node:path";
+import { Database } from "bun:sqlite";
+import { drizzle } from "drizzle-orm/bun-sqlite";
+import * as schema from "./schema";
+
+function databasePathFromEnv(): string {
+  const raw = process.env.DATABASE_URL ?? "file:./pigent.db";
+  const withoutPrefix = raw.startsWith("file:") ? raw.slice("file:".length) : raw;
+  return resolve(withoutPrefix);
+}
+
+const databasePath = databasePathFromEnv();
+mkdirSync(dirname(databasePath), { recursive: true });
+
+export const sqlite = new Database(databasePath);
+export const db = drizzle(sqlite, { schema });
+
+export type DbClient = typeof db;
+
+export function getDatabasePath(): string {
+  return databasePath;
+}

package/src/db/repositories/AgentRepository.ts

@@ -0,0 +1,45 @@
+import { eq } from "drizzle-orm";
+import type { LoadedAgentConfig } from "../../config/schemas";
+import type { DbClient } from "../client";
+import { agents, type AgentRow } from "../schema";
+
+export class AgentRepository {
+  constructor(private readonly db: DbClient) {}
+
+  async upsertLoadedAgent(agent: LoadedAgentConfig): Promise<void> {
+    const now = Date.now();
+    const configJson = JSON.stringify(agent);
+
+    await this.db
+      .insert(agents)
+      .values({
+        id: agent.id,
+        name: agent.name,
+        profile: agent.profile,
+        workspace: agent.workspace,
+        configJson,
+        systemPrompt: agent.systemPrompt,
+        createdAt: now,
+        updatedAt: now,
+      })
+      .onConflictDoUpdate({
+        target: agents.id,
+        set: {
+          name: agent.name,
+          profile: agent.profile,
+          workspace: agent.workspace,
+          configJson,
+          systemPrompt: agent.systemPrompt,
+          updatedAt: now,
+        },
+      });
+  }
+
+  async findById(id: string): Promise<AgentRow | null> {
+    const row = await this.db.query.agents.findFirst({
+      where: eq(agents.id, id),
+    });
+
+    return row ?? null;
+  }
+}