@fickydev/pigent 0.1.8 → 0.1.10

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;

package/src/pi/PiAvailableModels.ts

@@ -0,0 +1,23 @@
+import { AuthStorage, ModelRegistry } from "@earendil-works/pi-coding-agent";
+import type { Model } from "@earendil-works/pi-ai";
+
+export type AvailableModelChoice = {
+  id: string;
+  label: string;
+};
+
+export async function getAvailableModelChoices(): Promise<AvailableModelChoice[]> {
+  const authStorage = AuthStorage.create();
+  const modelRegistry = ModelRegistry.create(authStorage);
+  const models = await modelRegistry.getAvailable();
+
+  return models.map(toChoice).sort((a, b) => a.label.localeCompare(b.label));
+}
+
+function toChoice(model: Model<any>): AvailableModelChoice {
+  const modelWithName = model as Model<any> & { name?: string };
+  const id = `${model.provider}/${model.id}`;
+  const label = modelWithName.name ? `${modelWithName.name} (${id})` : id;
+
+  return { id, label };
+}