@lota-sdk/core 0.4.8 → 0.4.9

package/src/services/plan/plan-cycle.service.ts

@@ -0,0 +1,398 @@
+import { PlanArtifactSchema, PlanCycleRecordSchema, PlanRunSchema } from '@lota-sdk/shared'
+import type {
+  CarryForwardPolicy,
+  CycleSchedule,
+  PlanArtifactRecord,
+  PlanCycleRecord,
+  PlanDraft,
+  PlanRunStatus,
+  PlanScheduleSpec,
+  PlanTemplateRecord,
+} from '@lota-sdk/shared'
+import { Context, Schema, Effect, Layer } from 'effect'
+
+import type { RecordIdInput } from '../../db/record-id'
+import { ensureRecordId, recordIdToString } from '../../db/record-id'
+import type { SurrealDBService } from '../../db/service'
+import { TABLES } from '../../db/tables'
+import { runPromise } from '../../effect/runtime'
+import { DatabaseServiceTag } from '../../effect/services'
+import { nowDate, nowEpochMillis, unsafeDateFrom } from '../../utils/date-time'
+import type { makePlanSchedulerService } from './plan-scheduler.service'
+import { PlanSchedulerServiceTag } from './plan-scheduler.service'
+import type { makePlanTemplateService } from './plan-template.service'
+import { PlanTemplateServiceTag } from './plan-template.service'
+
+const TERMINAL_RUN_STATUSES: ReadonlySet<PlanRunStatus> = new Set(['completed', 'failed', 'aborted'])
+
+class PlanCycleNotFoundError extends Schema.TaggedErrorClass<PlanCycleNotFoundError>()('PlanCycleNotFoundError', {
+  cycleId: Schema.String,
+  message: Schema.String,
+}) {}
+
+class PlanTemplateNotFoundForCycleError extends Schema.TaggedErrorClass<PlanTemplateNotFoundForCycleError>()(
+  'PlanTemplateNotFoundForCycleError',
+  { templateId: Schema.String, message: Schema.String },
+) {}
+
+function cycleScheduleToSpec(schedule: CycleSchedule): PlanScheduleSpec {
+  const startAt = schedule.startAt ? unsafeDateFrom(schedule.startAt) : undefined
+  const isFutureStart = startAt && startAt.getTime() > nowEpochMillis()
+
+  if (isFutureStart) {
+    return { type: 'absolute', at: startAt.toISOString(), missedPolicy: 'run-immediately' }
+  }
+
+  const cron = frequencyToCron(schedule.frequency, schedule.customIntervalMs)
+  if (cron) {
+    return { type: 'cron', cron, missedPolicy: 'run-immediately' }
+  }
+
+  if (schedule.frequency === 'biweekly') {
+    return { type: 'monitoring', intervalMs: 14 * 24 * 60 * 60 * 1000, missedPolicy: 'run-immediately' }
+  }
+
+  if (schedule.frequency === 'custom' && schedule.customIntervalMs) {
+    return { type: 'monitoring', intervalMs: schedule.customIntervalMs, missedPolicy: 'run-immediately' }
+  }
+
+  return { type: 'cron', cron: '0 0 * * *', missedPolicy: 'run-immediately' }
+}
+
+function frequencyToCron(frequency: CycleSchedule['frequency'], _customIntervalMs?: number): string | null {
+  switch (frequency) {
+    case 'daily':
+      return '0 0 * * *'
+    case 'weekly':
+      return '0 0 * * 1'
+    case 'monthly':
+      return '0 0 1 * *'
+    case 'quarterly':
+      return '0 0 1 */3 *'
+    case 'biweekly':
+    case 'custom':
+      return null
+  }
+}
+
+function buildCarryForwardDraft(params: {
+  template: PlanTemplateRecord
+  previousRunArtifacts: PlanArtifactRecord[]
+  policy: CarryForwardPolicy
+}): PlanDraft {
+  const draft = { ...params.template.draft }
+
+  if (params.policy === 'none' || params.previousRunArtifacts.length === 0) {
+    return draft
+  }
+
+  let artifacts: PlanArtifactRecord[]
+  if (params.policy === 'incomplete-only') {
+    artifacts = params.previousRunArtifacts.filter((a) => a.kind === 'markdown' || a.kind === 'json')
+  } else {
+    artifacts = [...params.previousRunArtifacts]
+  }
+
+  if (artifacts.length > 0) {
+    const carryContext = artifacts.map((a) => `[carry-forward] ${a.name}: ${a.pointer}`)
+    draft.objective = `${draft.objective}\n\nCarry-forward context:\n${carryContext.join('\n')}`
+  }
+
+  return draft
+}
+
+interface PlanCycleDeps {
+  db: SurrealDBService
+  planSchedulerService: ReturnType<typeof makePlanSchedulerService>
+  planTemplateService: ReturnType<typeof makePlanTemplateService>
+}
+
+export function makePlanCycleService(deps: PlanCycleDeps) {
+  const { db, planSchedulerService, planTemplateService } = deps
+
+  function getCycleEffect(cycleId: RecordIdInput) {
+    return db.findOne(TABLES.PLAN_CYCLE, { id: ensureRecordId(cycleId, TABLES.PLAN_CYCLE) }, PlanCycleRecordSchema)
+  }
+
+  function createCycleEffect(params: {
+    organizationId: RecordIdInput
+    threadId: RecordIdInput
+    templateId: RecordIdInput
+    name: string
+    schedule: CycleSchedule
+    carryForwardPolicy?: CarryForwardPolicy
+    leadAgentId: string
+  }) {
+    return Effect.gen(function* () {
+      const now = nowDate()
+
+      const cycle = yield* db.create(
+        TABLES.PLAN_CYCLE,
+        {
+          organizationId: ensureRecordId(params.organizationId, TABLES.ORGANIZATION),
+          threadId: ensureRecordId(params.threadId, TABLES.THREAD),
+          templateId: ensureRecordId(params.templateId, TABLES.PLAN_TEMPLATE),
+          name: params.name,
+          schedule: params.schedule,
+          carryForwardPolicy: params.carryForwardPolicy ?? 'incomplete-only',
+          status: 'active',
+          currentIteration: 0,
+          createdAt: now,
+        },
+        PlanCycleRecordSchema,
+      )
+
+      const createResult = yield* planTemplateService.instantiate({
+        templateId: params.templateId,
+        organizationId: params.organizationId,
+        threadId: params.threadId,
+        leadAgentId: params.leadAgentId,
+      })
+
+      const createdRunId = createResult.plan?.runId
+      const scheduleSpec = cycleScheduleToSpec(params.schedule)
+      const scheduleParams: {
+        organizationId: RecordIdInput
+        threadId: RecordIdInput
+        scheduleSpec: PlanScheduleSpec
+        runId?: RecordIdInput
+      } = { organizationId: params.organizationId, threadId: params.threadId, scheduleSpec }
+      if (createdRunId !== undefined) {
+        scheduleParams.runId = ensureRecordId(createdRunId, TABLES.PLAN_RUN)
+      }
+
+      const scheduleRecord = yield* planSchedulerService.createSchedule(scheduleParams)
+
+      const updatedPayload: { scheduleId: RecordIdInput; currentRunId?: RecordIdInput; currentIteration: number } = {
+        scheduleId: ensureRecordId(scheduleRecord.id, TABLES.PLAN_SCHEDULE),
+        currentIteration: 1,
+      }
+      if (createdRunId !== undefined) {
+        updatedPayload.currentRunId = ensureRecordId(createdRunId, TABLES.PLAN_RUN)
+      }
+
+      const updated = yield* db.update(
+        TABLES.PLAN_CYCLE,
+        ensureRecordId(cycle.id, TABLES.PLAN_CYCLE),
+        updatedPayload,
+        PlanCycleRecordSchema,
+      )
+
+      return updated ?? cycle
+    })
+  }
+
+  function advanceCycleEffect(cycleId: RecordIdInput) {
+    return Effect.gen(function* () {
+      const cycle = yield* getCycleEffect(cycleId)
+      if (!cycle) {
+        return yield* new PlanCycleNotFoundError({
+          cycleId: recordIdToString(cycleId, TABLES.PLAN_CYCLE),
+          message: `Cycle not found: ${recordIdToString(cycleId, TABLES.PLAN_CYCLE)}`,
+        })
+      }
+
+      if (cycle.status !== 'active') {
+        return
+      }
+
+      const currentRunId = cycle.currentRunId
+      if (currentRunId !== undefined) {
+        const runRecord = yield* db.findOne(
+          TABLES.PLAN_RUN,
+          { id: ensureRecordId(currentRunId, TABLES.PLAN_RUN) },
+          PlanRunSchema,
+        )
+        if (runRecord && !TERMINAL_RUN_STATUSES.has(runRecord.status)) {
+          return
+        }
+      }
+
+      const template = yield* planTemplateService.getTemplate(cycle.templateId)
+      if (!template) {
+        return yield* new PlanTemplateNotFoundForCycleError({
+          templateId: recordIdToString(cycle.templateId, TABLES.PLAN_TEMPLATE),
+          message: `Template not found for cycle: ${recordIdToString(cycle.templateId, TABLES.PLAN_TEMPLATE)}`,
+        })
+      }
+
+      let previousRunArtifacts: PlanArtifactRecord[] = []
+      if (currentRunId !== undefined) {
+        previousRunArtifacts = yield* db.findMany(
+          TABLES.PLAN_ARTIFACT,
+          { runId: ensureRecordId(currentRunId, TABLES.PLAN_RUN) },
+          PlanArtifactSchema,
+          { orderBy: 'createdAt', orderDir: 'ASC' },
+        )
+      }
+
+      const draft = buildCarryForwardDraft({ template, previousRunArtifacts, policy: cycle.carryForwardPolicy })
+
+      const result = yield* planTemplateService.instantiate({
+        templateId: cycle.templateId,
+        organizationId: cycle.organizationId,
+        threadId: cycle.threadId,
+        leadAgentId: 'system',
+        overrides: draft,
+      })
+
+      const newRunId = result.plan?.runId
+      const updatePayload: { currentRunId?: RecordIdInput; currentIteration: number } = {
+        currentIteration: cycle.currentIteration + 1,
+      }
+      if (newRunId !== undefined) {
+        updatePayload.currentRunId = ensureRecordId(newRunId, TABLES.PLAN_RUN)
+      }
+
+      yield* db.update(
+        TABLES.PLAN_CYCLE,
+        ensureRecordId(cycleId, TABLES.PLAN_CYCLE),
+        updatePayload,
+        PlanCycleRecordSchema,
+      )
+    })
+  }
+
+  function cancelCycleEffect(cycleId: RecordIdInput) {
+    return Effect.gen(function* () {
+      const cycle = yield* getCycleEffect(cycleId)
+      if (!cycle) {
+        return yield* new PlanCycleNotFoundError({
+          cycleId: recordIdToString(cycleId, TABLES.PLAN_CYCLE),
+          message: `Cycle not found: ${recordIdToString(cycleId, TABLES.PLAN_CYCLE)}`,
+        })
+      }
+
+      const scheduleId = cycle.scheduleId
+      if (scheduleId !== undefined) {
+        yield* planSchedulerService.cancelSchedule(scheduleId)
+      }
+
+      yield* db.update(
+        TABLES.PLAN_CYCLE,
+        ensureRecordId(cycleId, TABLES.PLAN_CYCLE),
+        { status: 'cancelled' },
+        PlanCycleRecordSchema,
+      )
+    })
+  }
+
+  function pauseCycleEffect(cycleId: RecordIdInput) {
+    return Effect.gen(function* () {
+      const cycle = yield* getCycleEffect(cycleId)
+      if (!cycle) {
+        return yield* new PlanCycleNotFoundError({
+          cycleId: recordIdToString(cycleId, TABLES.PLAN_CYCLE),
+          message: `Cycle not found: ${recordIdToString(cycleId, TABLES.PLAN_CYCLE)}`,
+        })
+      }
+
+      const scheduleId = cycle.scheduleId
+      if (scheduleId !== undefined) {
+        yield* planSchedulerService.pauseSchedule(scheduleId)
+      }
+
+      yield* db.update(
+        TABLES.PLAN_CYCLE,
+        ensureRecordId(cycleId, TABLES.PLAN_CYCLE),
+        { status: 'paused' },
+        PlanCycleRecordSchema,
+      )
+    })
+  }
+
+  function resumeCycleEffect(cycleId: RecordIdInput) {
+    return Effect.gen(function* () {
+      const cycle = yield* getCycleEffect(cycleId)
+      if (!cycle) {
+        return yield* new PlanCycleNotFoundError({
+          cycleId: recordIdToString(cycleId, TABLES.PLAN_CYCLE),
+          message: `Cycle not found: ${recordIdToString(cycleId, TABLES.PLAN_CYCLE)}`,
+        })
+      }
+
+      const scheduleId = cycle.scheduleId
+      if (scheduleId !== undefined) {
+        yield* planSchedulerService.resumeSchedule(scheduleId)
+      }
+
+      yield* db.update(
+        TABLES.PLAN_CYCLE,
+        ensureRecordId(cycleId, TABLES.PLAN_CYCLE),
+        { status: 'active' },
+        PlanCycleRecordSchema,
+      )
+    })
+  }
+
+  function listCyclesEffect(threadId: RecordIdInput) {
+    return db.findMany(
+      TABLES.PLAN_CYCLE,
+      { threadId: ensureRecordId(threadId, TABLES.THREAD) },
+      PlanCycleRecordSchema,
+      { orderBy: 'createdAt', orderDir: 'ASC' },
+    )
+  }
+
+  return {
+    cycleScheduleToSpec,
+    createCycle(params: {
+      organizationId: RecordIdInput
+      threadId: RecordIdInput
+      templateId: RecordIdInput
+      name: string
+      schedule: CycleSchedule
+      carryForwardPolicy?: CarryForwardPolicy
+      leadAgentId: string
+    }): Promise<PlanCycleRecord> {
+      return runPromise(createCycleEffect(params))
+    },
+
+    advanceCycle(cycleId: RecordIdInput): Promise<void> {
+      return runPromise(advanceCycleEffect(cycleId))
+    },
+
+    buildCarryForwardDraft(params: {
+      template: PlanTemplateRecord
+      previousRunArtifacts: PlanArtifactRecord[]
+      policy: CarryForwardPolicy
+    }): PlanDraft {
+      return buildCarryForwardDraft(params)
+    },
+
+    cancelCycle(cycleId: RecordIdInput): Promise<void> {
+      return runPromise(cancelCycleEffect(cycleId))
+    },
+
+    pauseCycle(cycleId: RecordIdInput): Promise<void> {
+      return runPromise(pauseCycleEffect(cycleId))
+    },
+
+    resumeCycle(cycleId: RecordIdInput): Promise<void> {
+      return runPromise(resumeCycleEffect(cycleId))
+    },
+
+    listCycles(threadId: RecordIdInput): Promise<PlanCycleRecord[]> {
+      return runPromise(listCyclesEffect(threadId))
+    },
+
+    getCycle(cycleId: RecordIdInput): Promise<PlanCycleRecord | null> {
+      return runPromise(getCycleEffect(cycleId))
+    },
+  }
+}
+
+export class PlanCycleServiceTag extends Context.Service<
+  PlanCycleServiceTag,
+  ReturnType<typeof makePlanCycleService>
+>()('PlanCycleService') {}
+
+export const PlanCycleServiceLive = Layer.effect(
+  PlanCycleServiceTag,
+  Effect.gen(function* () {
+    const db = yield* DatabaseServiceTag
+    const planSchedulerService = yield* PlanSchedulerServiceTag
+    const planTemplateService = yield* PlanTemplateServiceTag
+    return makePlanCycleService({ db, planSchedulerService, planTemplateService })
+  }),
+)