@lota-sdk/core 0.4.7 → 0.4.9

package/src/services/agent-activity.service.ts

@@ -1,23 +1,23 @@
 import type {
   AgentActivityCounts,
   AgentActivityEntry,
-  AgentActivityResponse,
-  AgentProjectEntry,
-  MyTasksResponse,
   PlanBoardColumn,
-  PlanBoardResponse,
   PlanNodeCard,
   PlanViewNode,
-  PlanViewResponse,
   SerializableExecutionPlan,
   SerializablePlanNode,
 } from '@lota-sdk/shared'
+import { Context, Schema, Effect, Layer } from 'effect'
 
-import { agentRoster } from '../config/agent-defaults'
+import { getAgentRoster } from '../config/agent-defaults'
 import { serverLogger } from '../config/logger'
-import { executionPlanService } from './execution-plan.service'
-import { threadService } from './thread.service'
-import type { NormalizedThread } from './thread.types'
+import { toAwaitableEffect } from '../effect/awaitable-effect'
+import { unsafeDateFrom } from '../utils/date-time'
+import type { makeExecutionPlanService } from './execution-plan/execution-plan.service'
+import { ExecutionPlanServiceTag } from './execution-plan/execution-plan.service'
+import type { makeThreadService } from './thread/thread.service'
+import { ThreadServiceTag } from './thread/thread.service'
+import type { NormalizedThread } from './thread/thread.types'
 
 const BOARD_COLUMN_ORDER = ['ready', 'running', 'awaiting-human', 'completed', 'blocked', 'failed'] as const
 type BoardColumnStatus = (typeof BOARD_COLUMN_ORDER)[number]
@@ -37,10 +37,15 @@ type ActivePlanEntry = {
 }
 
 type AgentActivityDeps = {
-  executionPlanService: Pick<typeof executionPlanService, 'getActivePlansForThread'>
-  threadService: Pick<typeof threadService, 'listThreads'>
+  executionPlanService: Pick<ReturnType<typeof makeExecutionPlanService>, 'getActivePlansForThread'>
+  threadService: Pick<ReturnType<typeof makeThreadService>, 'listThreads'>
 }
 
+class AgentActivityServiceError extends Schema.TaggedErrorClass<AgentActivityServiceError>()(
+  'AgentActivityServiceError',
+  { message: Schema.String, cause: Schema.Defect },
+) {}
+
 function isPendingPlanApproval(plan: SerializableExecutionPlan): boolean {
   return plan.status === 'pending-approval'
 }
@@ -69,7 +74,7 @@ function createEmptyCounts(): AgentActivityCounts {
 
 function maxIsoDate(current: string | null, candidate: string): string {
   if (!current) return candidate
-  return new Date(candidate).getTime() > new Date(current).getTime() ? candidate : current
+  return unsafeDateFrom(candidate).getTime() > unsafeDateFrom(current).getTime() ? candidate : current
 }
 
 function incrementCounts(counts: AgentActivityCounts, rawStatus: string): void {
@@ -148,188 +153,245 @@ function buildPlanViewNode(
   }
 }
 
-export class AgentActivityService {
-  constructor(private readonly deps: AgentActivityDeps = { executionPlanService, threadService }) {}
-
-  async getBoard(userRef: string, orgRef: string): Promise<PlanBoardResponse> {
-    const activePlans = await this.getAllActivePlans(userRef, orgRef)
-    const cards = activePlans
-      .filter(({ plan }) => !isPendingPlanApproval(plan))
-      .flatMap(({ plan, thread }) => plan.nodes.map((node) => planNodeToCard(node, plan, thread.id, thread.title)))
-
-    const columns: PlanBoardColumn[] = BOARD_COLUMN_ORDER.map((status) => ({
-      status,
-      label: COLUMN_LABELS[status],
-      nodes: cards.filter((card) => card.status === status),
-    }))
-
-    return {
-      columns,
-      summary: {
-        totalNodes: cards.length,
-        completedNodes: cards.filter((card) => card.status === 'completed').length,
-        activePlanCount: activePlans.length,
-        pendingApprovalCount: countPendingPlanApprovals(activePlans) + cards.filter((card) => card.hasApproval).length,
-      },
-    }
-  }
-
-  async getPlanView(orgRef: string, planRunId: string, userRef: string): Promise<PlanViewResponse | null> {
-    const activePlans = await this.getAllActivePlans(userRef, orgRef)
-    const match = activePlans.find(({ plan }) => plan.runId === planRunId)
-    if (!match) return null
-
-    const { plan, thread } = match
-    return {
-      planRunId: plan.runId,
-      title: plan.title,
-      objective: plan.objective,
-      status: plan.status,
-      leadAgentId: plan.leadAgentId,
-      progress: { completed: plan.progress.completed + plan.progress.partial, total: plan.progress.total },
-      nodes: plan.nodes.map((node) => buildPlanViewNode(node, plan, thread.id, thread.title)),
-      edges: plan.edges.map((edge) => ({ from: edge.source, to: edge.target })),
-    }
-  }
-
-  async getMyTasks(userRef: string, orgRef: string): Promise<MyTasksResponse> {
-    const activePlans = await this.getAllActivePlans(userRef, orgRef)
-    const tasks: PlanNodeCard[] = []
-    const pendingPlanApprovalCount = countPendingPlanApprovals(activePlans)
-
-    for (const { plan, thread } of activePlans) {
-      if (isPendingPlanApproval(plan)) {
-        continue
+export function getBoard(userRef: string, orgRef: string, deps: AgentActivityDeps) {
+  return toAwaitableEffect(
+    Effect.gen(function* () {
+      const activePlans = yield* getAllActivePlans(userRef, orgRef, deps)
+      const cards = activePlans
+        .filter(({ plan }) => !isPendingPlanApproval(plan))
+        .flatMap(({ plan, thread }) => plan.nodes.map((node) => planNodeToCard(node, plan, thread.id, thread.title)))
+
+      const columns: PlanBoardColumn[] = BOARD_COLUMN_ORDER.map((status) => ({
+        status,
+        label: COLUMN_LABELS[status],
+        nodes: cards.filter((card) => card.status === status),
+      }))
+
+      return {
+        columns,
+        summary: {
+          totalNodes: cards.length,
+          completedNodes: cards.filter((card) => card.status === 'completed').length,
+          activePlanCount: activePlans.length,
+          pendingApprovalCount:
+            countPendingPlanApprovals(activePlans) + cards.filter((card) => card.hasApproval).length,
+        },
       }
+    }),
+  )
+}
 
-      for (const node of plan.nodes) {
-        const humanOwned = node.owner.executorType === 'user'
-        const awaitingHuman = node.status === 'awaiting-human'
-        if (!humanOwned && !awaitingHuman) continue
-
-        tasks.push(planNodeToCard(node, plan, thread.id, thread.title))
+export function getPlanView(orgRef: string, planRunId: string, userRef: string, deps: AgentActivityDeps) {
+  return toAwaitableEffect(
+    Effect.gen(function* () {
+      const activePlans = yield* getAllActivePlans(userRef, orgRef, deps)
+      const match = activePlans.find(({ plan }) => plan.runId === planRunId)
+      if (!match) return null
+
+      const { plan, thread } = match
+      return {
+        planRunId: plan.runId,
+        title: plan.title,
+        objective: plan.objective,
+        status: plan.status,
+        leadAgentId: plan.leadAgentId,
+        progress: { completed: plan.progress.completed + plan.progress.partial, total: plan.progress.total },
+        nodes: plan.nodes.map((node) => buildPlanViewNode(node, plan, thread.id, thread.title)),
+        edges: plan.edges.map((edge) => ({ from: edge.source, to: edge.target })),
       }
-    }
+    }),
+  )
+}
 
-    return { tasks, pendingApprovalCount: pendingPlanApprovalCount + tasks.filter((task) => task.hasApproval).length }
-  }
+export function getMyTasks(userRef: string, orgRef: string, deps: AgentActivityDeps) {
+  return toAwaitableEffect(
+    Effect.gen(function* () {
+      const activePlans = yield* getAllActivePlans(userRef, orgRef, deps)
+      const tasks: PlanNodeCard[] = []
+      const pendingPlanApprovalCount = countPendingPlanApprovals(activePlans)
 
-  async getAgentActivity(userRef: string, orgRef: string): Promise<AgentActivityResponse> {
-    const activePlans = await this.getAllActivePlans(userRef, orgRef)
-    const activityByAgent = new Map<string, AgentActivityEntry>()
+      for (const { plan, thread } of activePlans) {
+        if (isPendingPlanApproval(plan)) {
+          continue
+        }
 
-    for (const agentId of agentRoster) {
-      activityByAgent.set(agentId, this.createEmptyEntry(agentId))
-    }
+        for (const node of plan.nodes) {
+          const humanOwned = node.owner.executorType === 'user'
+          const awaitingHuman = node.status === 'awaiting-human'
+          if (!humanOwned && !awaitingHuman) continue
 
-    for (const { plan, thread } of activePlans) {
-      if (isPendingPlanApproval(plan)) {
-        if (plan.leadAgentId.trim()) {
-          const leadEntry = this.ensureEntry(activityByAgent, plan.leadAgentId)
-          leadEntry.isLeadingActivePlan = true
-          this.ensureProjectEntry(leadEntry.projects, {
-            threadId: thread.id,
-            threadTitle: thread.title,
-            planRunId: plan.runId,
-            planTitle: plan.title,
-            status: plan.status,
-          })
-          leadEntry.isRunning = leadEntry.isRunning || thread.isRunning
-          leadEntry.lastActiveAt = maxIsoDate(leadEntry.lastActiveAt, thread.updatedAt)
+          tasks.push(planNodeToCard(node, plan, thread.id, thread.title))
         }
-        continue
       }
 
-      const involvedAgents = new Set<string>()
-
-      for (const node of plan.nodes) {
-        if (node.owner.executorType !== 'agent') continue
-
-        const agentId = node.owner.ref
-        const entry = this.ensureEntry(activityByAgent, agentId)
-        involvedAgents.add(agentId)
-        incrementCounts(entry.counts, node.status)
+      return { tasks, pendingApprovalCount: pendingPlanApprovalCount + tasks.filter((task) => task.hasApproval).length }
+    }),
+  )
+}
 
-        if (!isCompletedStatus(node.status)) {
-          entry.tasks.push(planNodeToCard(node, plan, thread.id, thread.title))
-        }
+export function getAgentActivity(userRef: string, orgRef: string, deps: AgentActivityDeps) {
+  return toAwaitableEffect(
+    Effect.gen(function* () {
+      const [activePlans, userTasks] = yield* Effect.all([
+        getAllActivePlans(userRef, orgRef, deps),
+        getMyTasks(userRef, orgRef, deps),
+      ])
+      const activityByAgent = new Map<string, AgentActivityEntry>()
+
+      const agentRoster = getAgentRoster()
+      for (const agentId of agentRoster) {
+        activityByAgent.set(agentId, {
+          agentId,
+          counts: createEmptyCounts(),
+          tasks: [],
+          projects: [],
+          isLeadingActivePlan: false,
+          isRunning: false,
+          lastActiveAt: null,
+        })
       }
 
-      if (plan.leadAgentId.trim()) {
-        const leadEntry = this.ensureEntry(activityByAgent, plan.leadAgentId)
-        leadEntry.isLeadingActivePlan = true
-        involvedAgents.add(plan.leadAgentId)
-      }
+      for (const { plan, thread } of activePlans) {
+        if (isPendingPlanApproval(plan)) {
+          if (plan.leadAgentId.trim()) {
+            const leadEntry = activityByAgent.get(plan.leadAgentId) ?? {
+              agentId: plan.leadAgentId,
+              counts: createEmptyCounts(),
+              tasks: [],
+              projects: [],
+              isLeadingActivePlan: false,
+              isRunning: false,
+              lastActiveAt: null,
+            }
+            activityByAgent.set(plan.leadAgentId, leadEntry)
+            leadEntry.isLeadingActivePlan = true
+            if (!leadEntry.projects.some((project) => project.planRunId === plan.runId)) {
+              leadEntry.projects.push({
+                threadId: thread.id,
+                threadTitle: thread.title,
+                planRunId: plan.runId,
+                planTitle: plan.title,
+                status: plan.status,
+              })
+            }
+            leadEntry.isRunning = leadEntry.isRunning || thread.isRunning
+            leadEntry.lastActiveAt = maxIsoDate(leadEntry.lastActiveAt, thread.updatedAt)
+          }
+          continue
+        }
 
-      for (const agentId of involvedAgents) {
-        const entry = this.ensureEntry(activityByAgent, agentId)
-        this.ensureProjectEntry(entry.projects, {
-          threadId: thread.id,
-          threadTitle: thread.title,
-          planRunId: plan.runId,
-          planTitle: plan.title,
-          status: plan.status,
-        })
+        const involvedAgents = new Set<string>()
+
+        for (const node of plan.nodes) {
+          if (node.owner.executorType !== 'agent') continue
+
+          const agentId = node.owner.ref
+          const entry =
+            activityByAgent.get(agentId) ??
+            ({
+              agentId,
+              counts: createEmptyCounts(),
+              tasks: [],
+              projects: [],
+              isLeadingActivePlan: false,
+              isRunning: false,
+              lastActiveAt: null,
+            } as AgentActivityEntry)
+          activityByAgent.set(agentId, entry)
+          involvedAgents.add(agentId)
+          incrementCounts(entry.counts, node.status)
+
+          if (!isCompletedStatus(node.status)) {
+            entry.tasks.push(planNodeToCard(node, plan, thread.id, thread.title))
+          }
+        }
 
-        entry.isRunning = entry.isRunning || thread.isRunning
-        entry.lastActiveAt = maxIsoDate(entry.lastActiveAt, thread.updatedAt)
-      }
-    }
+        if (plan.leadAgentId.trim()) {
+          const leadEntry = activityByAgent.get(plan.leadAgentId) ?? {
+            agentId: plan.leadAgentId,
+            counts: createEmptyCounts(),
+            tasks: [],
+            projects: [],
+            isLeadingActivePlan: false,
+            isRunning: false,
+            lastActiveAt: null,
+          }
+          activityByAgent.set(plan.leadAgentId, leadEntry)
+          leadEntry.isLeadingActivePlan = true
+          involvedAgents.add(plan.leadAgentId)
+        }
 
-    const userTasks = await this.getMyTasks(userRef, orgRef)
-    const agents = [...activityByAgent.values()].sort((left, right) => {
-      const leftIndex = agentRoster.indexOf(left.agentId)
-      const rightIndex = agentRoster.indexOf(right.agentId)
-      if (leftIndex !== -1 || rightIndex !== -1) {
-        if (leftIndex === -1) return 1
-        if (rightIndex === -1) return -1
-        return leftIndex - rightIndex
+        for (const agentId of involvedAgents) {
+          const entry = activityByAgent.get(agentId)
+          if (!entry) continue
+
+          if (!entry.projects.some((project) => project.planRunId === plan.runId)) {
+            entry.projects.push({
+              threadId: thread.id,
+              threadTitle: thread.title,
+              planRunId: plan.runId,
+              planTitle: plan.title,
+              status: plan.status,
+            })
+          }
+
+          entry.isRunning = entry.isRunning || thread.isRunning
+          entry.lastActiveAt = maxIsoDate(entry.lastActiveAt, thread.updatedAt)
+        }
       }
-      return left.agentId.localeCompare(right.agentId)
-    })
-
-    return {
-      agents,
-      userActivity: {
-        taskCount: userTasks.tasks.length,
-        pendingApprovalCount: userTasks.pendingApprovalCount,
-        awaitingHumanCount: userTasks.tasks.filter((task) => task.status === 'awaiting-human').length,
-        lastActiveAt: activePlans.reduce<string | null>(
-          (latest, entry) => maxIsoDate(latest, entry.thread.updatedAt),
-          null,
-        ),
-      },
-      totalActivePlans: activePlans.length,
-    }
-  }
 
-  async getAllActivePlans(userRef: string, orgRef: string): Promise<ActivePlanEntry[]> {
-    const threads = await this.listRelevantThreads(userRef, orgRef)
-    const planResults = await Promise.all(
-      threads.map(async (thread) => {
-        try {
-          const plans = await this.deps.executionPlanService.getActivePlansForThread(thread.id)
-          return plans.map((plan) => ({ plan, thread }))
-        } catch (error) {
-          serverLogger.error`Failed to load active plans for thread ${thread.id}: ${error}`
-          return []
+      const agents = [...activityByAgent.values()].sort((left, right) => {
+        const leftIndex = agentRoster.indexOf(left.agentId)
+        const rightIndex = agentRoster.indexOf(right.agentId)
+        if (leftIndex !== -1 || rightIndex !== -1) {
+          if (leftIndex === -1) return 1
+          if (rightIndex === -1) return -1
+          return leftIndex - rightIndex
         }
-      }),
-    )
-
-    return planResults.flat()
-  }
+        return left.agentId.localeCompare(right.agentId)
+      })
+
+      return {
+        agents,
+        userActivity: {
+          taskCount: userTasks.tasks.length,
+          pendingApprovalCount: userTasks.pendingApprovalCount,
+          awaitingHumanCount: userTasks.tasks.filter((task) => task.status === 'awaiting-human').length,
+          lastActiveAt: activePlans.reduce<string | null>(
+            (latest, entry) => maxIsoDate(latest, entry.thread.updatedAt),
+            null,
+          ),
+        },
+        totalActivePlans: activePlans.length,
+      }
+    }),
+  )
+}
 
-  private async listRelevantThreads(userRef: string, orgRef: string): Promise<NormalizedThread[]> {
-    const [direct, core, group] = await Promise.all([
-      this.deps.threadService.listThreads(userRef, orgRef, { type: 'default', includeArchived: false }),
-      this.deps.threadService.listThreads(userRef, orgRef, { type: 'thread', includeArchived: false }),
-      this.deps.threadService.listThreads(userRef, orgRef, {
-        type: 'group',
-        includeArchived: false,
-        take: 500,
-        page: 1,
-      }),
+export function getAllActivePlans(userRef: string, orgRef: string, deps: AgentActivityDeps) {
+  return Effect.gen(function* () {
+    const [direct, core, group] = yield* Effect.all([
+      deps.threadService
+        .listThreads(userRef, orgRef, { type: 'default', includeArchived: false })
+        .pipe(
+          Effect.mapError(
+            (cause) => new AgentActivityServiceError({ message: 'Failed to load default threads.', cause }),
+          ),
+        ),
+      deps.threadService
+        .listThreads(userRef, orgRef, { type: 'thread', includeArchived: false })
+        .pipe(
+          Effect.mapError(
+            (cause) => new AgentActivityServiceError({ message: 'Failed to load thread threads.', cause }),
+          ),
+        ),
+      deps.threadService
+        .listThreads(userRef, orgRef, { type: 'group', includeArchived: false, take: 500, page: 1 })
+        .pipe(
+          Effect.mapError(
+            (cause) => new AgentActivityServiceError({ message: 'Failed to load group threads.', cause }),
+          ),
+        ),
     ])
 
     const deduped = new Map<string, NormalizedThread>()
@@ -337,39 +399,61 @@ export class AgentActivityService {
       deduped.set(thread.id, thread)
     }
 
-    return [...deduped.values()]
-  }
+    const threads = [...deduped.values()]
+    const planResults = yield* Effect.all(
+      threads.map((thread) =>
+        Effect.catch(
+          deps.executionPlanService.getActivePlansForThread(thread.id).pipe(
+            Effect.mapError(
+              (cause) =>
+                new AgentActivityServiceError({
+                  message: `Failed to load active plans for thread ${thread.id}.`,
+                  cause,
+                }),
+            ),
+            Effect.map((plans) => plans.map((plan): ActivePlanEntry => ({ plan, thread }))),
+          ),
+          (error) =>
+            Effect.sync(() => {
+              serverLogger.error`Failed to load active plans for thread ${thread.id}: ${error}`
+              return [] as ActivePlanEntry[]
+            }),
+        ),
+      ),
+    )
 
-  private createEmptyEntry(agentId: string): AgentActivityEntry {
-    return {
-      agentId,
-      counts: createEmptyCounts(),
-      tasks: [],
-      projects: [],
-      isLeadingActivePlan: false,
-      isRunning: false,
-      lastActiveAt: null,
-    }
-  }
+    return planResults.flat()
+  })
+}
 
-  private ensureEntry(entries: Map<string, AgentActivityEntry>, agentId: string): AgentActivityEntry {
-    const existing = entries.get(agentId)
-    if (existing) {
-      return existing
-    }
+function resolveAgentActivityDeps(deps: AgentActivityDeps | (() => AgentActivityDeps)): AgentActivityDeps {
+  return typeof deps === 'function' ? deps() : deps
+}
 
-    const created = this.createEmptyEntry(agentId)
-    entries.set(agentId, created)
-    return created
+export function createAgentActivityService(deps: AgentActivityDeps | (() => AgentActivityDeps)) {
+  return {
+    getBoard: (userRef: string, orgRef: string) => getBoard(userRef, orgRef, resolveAgentActivityDeps(deps)),
+    getPlanView: (orgRef: string, planRunId: string, userRef: string) =>
+      getPlanView(orgRef, planRunId, userRef, resolveAgentActivityDeps(deps)),
+    getMyTasks: (userRef: string, orgRef: string) => getMyTasks(userRef, orgRef, resolveAgentActivityDeps(deps)),
+    getAgentActivity: (userRef: string, orgRef: string) =>
+      getAgentActivity(userRef, orgRef, resolveAgentActivityDeps(deps)),
+    getAllActivePlans: (userRef: string, orgRef: string) =>
+      getAllActivePlans(userRef, orgRef, resolveAgentActivityDeps(deps)),
   }
+}
 
-  private ensureProjectEntry(projects: AgentProjectEntry[], next: AgentProjectEntry): void {
-    if (projects.some((project) => project.planRunId === next.planRunId)) {
-      return
-    }
+export type AgentActivityService = ReturnType<typeof createAgentActivityService>
 
-    projects.push(next)
-  }
-}
+export class AgentActivityServiceTag extends Context.Service<AgentActivityServiceTag, AgentActivityService>()(
+  'AgentActivityService',
+) {}
 
-export const agentActivityService = new AgentActivityService()
+export const AgentActivityServiceLive = Layer.effect(
+  AgentActivityServiceTag,
+  Effect.gen(function* () {
+    const executionPlanService = yield* ExecutionPlanServiceTag
+    const threadService = yield* ThreadServiceTag
+    return createAgentActivityService({ executionPlanService, threadService })
+  }),
+)