@lota-sdk/core 0.4.8 → 0.4.10

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

@@ -0,0 +1,405 @@
+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
+
+  const getCycleEffect = Effect.fn('PlanCycle.getCycle')(function* (cycleId: RecordIdInput) {
+    return yield* db.findOne(
+      TABLES.PLAN_CYCLE,
+      { id: ensureRecordId(cycleId, TABLES.PLAN_CYCLE) },
+      PlanCycleRecordSchema,
+    )
+  })
+
+  const createCycleEffect = Effect.fn('PlanCycle.createCycle')(function* (params: {
+    organizationId: RecordIdInput
+    threadId: RecordIdInput
+    templateId: RecordIdInput
+    name: string
+    schedule: CycleSchedule
+    carryForwardPolicy?: CarryForwardPolicy
+    leadAgentId: string
+  }) {
+    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,
+      )
+      .pipe(Effect.withSpan('PlanCycle.persistCycle'))
+
+    const createResult = yield* planTemplateService
+      .instantiate({
+        templateId: params.templateId,
+        organizationId: params.organizationId,
+        threadId: params.threadId,
+        leadAgentId: params.leadAgentId,
+      })
+      .pipe(Effect.withSpan('PlanCycle.instantiateTemplate'))
+
+    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
+  })
+
+  const advanceCycleEffect = Effect.fn('PlanCycle.advanceCycle')(function* (cycleId: RecordIdInput) {
+    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',
+        })
+        .pipe(Effect.withSpan('PlanCycle.loadPreviousRunArtifacts'))
+    }
+
+    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,
+      })
+      .pipe(Effect.withSpan('PlanCycle.instantiateTemplate'))
+
+    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,
+    )
+  })
+
+  const cancelCycleEffect = Effect.fn('PlanCycle.cancelCycle')(function* (cycleId: RecordIdInput) {
+    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,
+    )
+  })
+
+  const pauseCycleEffect = Effect.fn('PlanCycle.pauseCycle')(function* (cycleId: RecordIdInput) {
+    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,
+    )
+  })
+
+  const resumeCycleEffect = Effect.fn('PlanCycle.resumeCycle')(function* (cycleId: RecordIdInput) {
+    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,
+    )
+  })
+
+  const listCyclesEffect = Effect.fn('PlanCycle.listCycles')(function* (threadId: RecordIdInput) {
+    return yield* 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))
+    },
+    createCycleEffect,
+
+    advanceCycle(cycleId: RecordIdInput): Promise<void> {
+      return runPromise(advanceCycleEffect(cycleId))
+    },
+    advanceCycleEffect,
+
+    buildCarryForwardDraft(params: {
+      template: PlanTemplateRecord
+      previousRunArtifacts: PlanArtifactRecord[]
+      policy: CarryForwardPolicy
+    }): PlanDraft {
+      return buildCarryForwardDraft(params)
+    },
+
+    cancelCycle(cycleId: RecordIdInput): Promise<void> {
+      return runPromise(cancelCycleEffect(cycleId))
+    },
+    cancelCycleEffect,
+
+    pauseCycle(cycleId: RecordIdInput): Promise<void> {
+      return runPromise(pauseCycleEffect(cycleId))
+    },
+    pauseCycleEffect,
+
+    resumeCycle(cycleId: RecordIdInput): Promise<void> {
+      return runPromise(resumeCycleEffect(cycleId))
+    },
+    resumeCycleEffect,
+
+    listCycles(threadId: RecordIdInput): Promise<PlanCycleRecord[]> {
+      return runPromise(listCyclesEffect(threadId))
+    },
+    listCyclesEffect,
+
+    getCycle(cycleId: RecordIdInput): Promise<PlanCycleRecord | null> {
+      return runPromise(getCycleEffect(cycleId))
+    },
+    getCycleEffect,
+  }
+}
+
+export class PlanCycleServiceTag extends Context.Service<
+  PlanCycleServiceTag,
+  ReturnType<typeof makePlanCycleService>
+>()('@lota-sdk/core/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 })
+  }),
+)