@lota-sdk/core 0.4.8 → 0.4.10

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

@@ -1,240 +0,0 @@
-import { PlanCycleRecordSchema, PlanScheduleRecordSchema } from '@lota-sdk/shared'
-import type { PlanScheduleRecord, PlanScheduleSpec } from '@lota-sdk/shared'
-import { CronExpressionParser } from 'cron-parser'
-import { BoundQuery } from 'surrealdb'
-
-import type { RecordIdInput } from '../db/record-id'
-import { ensureRecordId, recordIdToString } from '../db/record-id'
-import { databaseService } from '../db/service'
-import { TABLES } from '../db/tables'
-import { toDatabaseDateTime } from '../utils/date-time'
-
-class PlanSchedulerService {
-  computeNextFireAt(spec: PlanScheduleSpec, baseTime: Date = new Date()): Date | null {
-    switch (spec.type) {
-      case 'immediate':
-        return baseTime
-
-      case 'absolute':
-        return spec.at ? new Date(spec.at) : null
-
-      case 'relative':
-        return spec.delayMs !== undefined ? new Date(baseTime.getTime() + spec.delayMs) : null
-
-      case 'cron': {
-        if (!spec.cron) return null
-        try {
-          const expr = CronExpressionParser.parse(spec.cron, { currentDate: baseTime })
-          const next = expr.next()
-          return next.toDate()
-        } catch {
-          return null
-        }
-      }
-
-      case 'monitoring':
-        return spec.intervalMs !== undefined ? new Date(baseTime.getTime() + spec.intervalMs) : null
-
-      default:
-        return null
-    }
-  }
-
-  async createSchedule(params: {
-    organizationId: RecordIdInput
-    threadId: RecordIdInput
-    planSpecId?: RecordIdInput
-    runId?: RecordIdInput
-    nodeId?: string
-    scheduleSpec: PlanScheduleSpec
-  }): Promise<PlanScheduleRecord> {
-    const nextFireAt = this.computeNextFireAt(params.scheduleSpec)
-    const now = new Date()
-
-    const record = await databaseService.create(
-      TABLES.PLAN_SCHEDULE,
-      {
-        organizationId: ensureRecordId(params.organizationId, TABLES.ORGANIZATION),
-        threadId: ensureRecordId(params.threadId, TABLES.THREAD),
-        planSpecId: params.planSpecId ? ensureRecordId(params.planSpecId, TABLES.PLAN_SPEC) : undefined,
-        runId: params.runId ? ensureRecordId(params.runId, TABLES.PLAN_RUN) : undefined,
-        nodeId: params.nodeId,
-        scheduleSpec: params.scheduleSpec,
-        status: 'active',
-        fireCount: 0,
-        ...(nextFireAt ? { nextFireAt: toDatabaseDateTime(nextFireAt) } : {}),
-        createdAt: now,
-      },
-      PlanScheduleRecordSchema,
-    )
-
-    // Enqueue a delayed BullMQ job to fire at the scheduled time
-    if (nextFireAt) {
-      const delay = Math.max(0, nextFireAt.getTime() - Date.now())
-      const { enqueueScheduleFire } = await import('../queues/plan-scheduler.queue')
-      await enqueueScheduleFire(recordIdToString(record.id, TABLES.PLAN_SCHEDULE), delay)
-    }
-
-    return record
-  }
-
-  /** Called by the BullMQ worker when a fire-schedule job executes. */
-  async fireScheduleById(scheduleId: string): Promise<void> {
-    const schedule = await databaseService.findOne(
-      TABLES.PLAN_SCHEDULE,
-      { id: ensureRecordId(scheduleId, TABLES.PLAN_SCHEDULE) },
-      PlanScheduleRecordSchema,
-    )
-
-    if (!schedule || schedule.status !== 'active') return
-
-    await this.fireSchedule(schedule)
-  }
-
-  async fireSchedule(schedule: PlanScheduleRecord): Promise<void> {
-    const now = new Date()
-    const newFireCount = schedule.fireCount + 1
-    const isRecurring = schedule.scheduleSpec.type === 'cron' || schedule.scheduleSpec.type === 'monitoring'
-    const maxReached = schedule.scheduleSpec.maxFires !== undefined && newFireCount >= schedule.scheduleSpec.maxFires
-
-    let nextFireAt: Date | null = null
-    let newStatus: 'active' | 'completed' = 'completed'
-
-    if (isRecurring && !maxReached) {
-      nextFireAt = this.computeNextFireAt(schedule.scheduleSpec, now)
-      newStatus = nextFireAt ? 'active' : 'completed'
-    }
-
-    await databaseService.update(
-      TABLES.PLAN_SCHEDULE,
-      schedule.id,
-      { fireCount: newFireCount, lastFiredAt: now, nextFireAt: toDatabaseDateTime(nextFireAt), status: newStatus },
-      PlanScheduleRecordSchema,
-    )
-
-    // Enqueue next fire for recurring schedules
-    if (newStatus === 'active' && nextFireAt) {
-      const delay = Math.max(0, nextFireAt.getTime() - Date.now())
-      const scheduleIdStr = recordIdToString(schedule.id, TABLES.PLAN_SCHEDULE)
-      const { enqueueScheduleFire } = await import('../queues/plan-scheduler.queue')
-      await enqueueScheduleFire(scheduleIdStr, delay)
-    }
-
-    let shouldRecoverDeadlineChecks = false
-
-    // Dispatch: node-level schedule — promote the delayed node
-    if (schedule.runId && schedule.nodeId) {
-      const { planExecutorService } = await import('./plan-executor.service')
-      await planExecutorService.promoteDelayedNode({
-        runId: recordIdToString(schedule.runId, TABLES.PLAN_RUN),
-        nodeId: schedule.nodeId,
-        emittedBy: 'plan-scheduler',
-      })
-      shouldRecoverDeadlineChecks = true
-    }
-
-    // Dispatch: plan-level schedule — advance a linked cycle or create a new run
-    if (schedule.planSpecId && !schedule.runId) {
-      const cycle = await databaseService.findOne(
-        TABLES.PLAN_CYCLE,
-        { scheduleId: ensureRecordId(schedule.id, TABLES.PLAN_SCHEDULE) },
-        PlanCycleRecordSchema,
-      )
-
-      if (cycle) {
-        const { planCycleService } = await import('./plan-cycle.service')
-        await planCycleService.advanceCycle(cycle.id)
-        shouldRecoverDeadlineChecks = true
-      }
-    }
-
-    if (shouldRecoverDeadlineChecks) {
-      const { planDeadlineService } = await import('./plan-deadline.service')
-      await planDeadlineService.recoverDeadlineChecks()
-    }
-  }
-
-  /** Re-enqueue BullMQ jobs for all active schedules. Called once at worker startup. */
-  async recoverActiveSchedules(): Promise<void> {
-    const activeSchedules = await databaseService.queryMany(
-      new BoundQuery(`SELECT * FROM ${TABLES.PLAN_SCHEDULE} WHERE status = $status ORDER BY nextFireAt ASC`, {
-        status: 'active',
-      }),
-      PlanScheduleRecordSchema,
-    )
-
-    const { enqueueScheduleFire } = await import('../queues/plan-scheduler.queue')
-
-    for (const schedule of activeSchedules) {
-      if (!schedule.nextFireAt) continue
-      const scheduleId = recordIdToString(schedule.id, TABLES.PLAN_SCHEDULE)
-      const delay = Math.max(0, new Date(schedule.nextFireAt).getTime() - Date.now())
-      await enqueueScheduleFire(scheduleId, delay)
-    }
-  }
-
-  async cancelSchedule(scheduleId: RecordIdInput): Promise<void> {
-    const idStr = recordIdToString(scheduleId, TABLES.PLAN_SCHEDULE)
-    const { removeScheduleFireJob } = await import('../queues/plan-scheduler.queue')
-    await removeScheduleFireJob(idStr)
-
-    await databaseService.update(
-      TABLES.PLAN_SCHEDULE,
-      ensureRecordId(scheduleId, TABLES.PLAN_SCHEDULE),
-      { status: 'cancelled' },
-      PlanScheduleRecordSchema,
-    )
-  }
-
-  async pauseSchedule(scheduleId: RecordIdInput): Promise<void> {
-    const idStr = recordIdToString(scheduleId, TABLES.PLAN_SCHEDULE)
-    const { removeScheduleFireJob } = await import('../queues/plan-scheduler.queue')
-    await removeScheduleFireJob(idStr)
-
-    await databaseService.update(
-      TABLES.PLAN_SCHEDULE,
-      ensureRecordId(scheduleId, TABLES.PLAN_SCHEDULE),
-      { status: 'paused' },
-      PlanScheduleRecordSchema,
-    )
-  }
-
-  async resumeSchedule(scheduleId: RecordIdInput): Promise<void> {
-    const schedule = await databaseService.findOne(
-      TABLES.PLAN_SCHEDULE,
-      { id: ensureRecordId(scheduleId, TABLES.PLAN_SCHEDULE) },
-      PlanScheduleRecordSchema,
-    )
-    if (!schedule) {
-      throw new Error(`Schedule not found: ${recordIdToString(scheduleId, TABLES.PLAN_SCHEDULE)}`)
-    }
-
-    const nextFireAt = this.computeNextFireAt(schedule.scheduleSpec)
-
-    await databaseService.update(
-      TABLES.PLAN_SCHEDULE,
-      ensureRecordId(scheduleId, TABLES.PLAN_SCHEDULE),
-      { status: 'active', nextFireAt: toDatabaseDateTime(nextFireAt) },
-      PlanScheduleRecordSchema,
-    )
-
-    // Re-enqueue the delayed fire job
-    if (nextFireAt) {
-      const delay = Math.max(0, nextFireAt.getTime() - Date.now())
-      const idStr = recordIdToString(scheduleId, TABLES.PLAN_SCHEDULE)
-      const { enqueueScheduleFire } = await import('../queues/plan-scheduler.queue')
-      await enqueueScheduleFire(idStr, delay)
-    }
-  }
-
-  async listSchedules(threadId: RecordIdInput): Promise<PlanScheduleRecord[]> {
-    return databaseService.findMany(
-      TABLES.PLAN_SCHEDULE,
-      { threadId: ensureRecordId(threadId, TABLES.THREAD) },
-      PlanScheduleRecordSchema,
-      { orderBy: 'createdAt', orderDir: 'ASC' },
-    )
-  }
-}
-
-export const planSchedulerService = new PlanSchedulerService()

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

@@ -1,177 +0,0 @@
-import { PlanTemplateRecordSchema } from '@lota-sdk/shared'
-import type { ExecutionPlanToolResultData, PlanArtifactRecord, PlanDraft, PlanTemplateRecord } from '@lota-sdk/shared'
-
-import type { RecordIdInput } from '../db/record-id'
-import { ensureRecordId, recordIdToString } from '../db/record-id'
-import { databaseService } from '../db/service'
-import { TABLES } from '../db/tables'
-import { executionPlanService } from './execution-plan.service'
-
-class PlanTemplateService {
-  private resolveSourceIdentity(params: { source?: 'user' | 'playbook' | 'system'; sourceRef?: string }) {
-    const source = params.source ?? 'user'
-    const sourceRef = params.sourceRef?.trim()
-
-    if (source !== 'user' && !sourceRef) {
-      throw new Error(`sourceRef is required when source is "${source}".`)
-    }
-
-    return { source, sourceRef }
-  }
-
-  async createTemplate(params: {
-    organizationId: RecordIdInput
-    name: string
-    description?: string
-    draft: PlanDraft
-    tags?: string[]
-    source?: 'user' | 'playbook' | 'system'
-    sourceRef?: string
-  }): Promise<PlanTemplateRecord> {
-    const now = new Date()
-    const identity = this.resolveSourceIdentity({ source: params.source, sourceRef: params.sourceRef })
-    return databaseService.create(
-      TABLES.PLAN_TEMPLATE,
-      {
-        organizationId: ensureRecordId(params.organizationId, TABLES.ORGANIZATION),
-        name: params.name,
-        ...(params.description ? { description: params.description } : {}),
-        draft: params.draft,
-        tags: params.tags ?? [],
-        source: identity.source,
-        ...(identity.sourceRef ? { sourceRef: identity.sourceRef } : {}),
-        createdAt: now,
-      },
-      PlanTemplateRecordSchema,
-    )
-  }
-
-  async getTemplate(templateId: RecordIdInput): Promise<PlanTemplateRecord | null> {
-    return databaseService.findOne(
-      TABLES.PLAN_TEMPLATE,
-      { id: ensureRecordId(templateId, TABLES.PLAN_TEMPLATE) },
-      PlanTemplateRecordSchema,
-    )
-  }
-
-  async getTemplateBySourceRef(params: {
-    organizationId: RecordIdInput
-    source: 'user' | 'playbook' | 'system'
-    sourceRef: string
-  }): Promise<PlanTemplateRecord | null> {
-    return await databaseService.findOne(
-      TABLES.PLAN_TEMPLATE,
-      {
-        organizationId: ensureRecordId(params.organizationId, TABLES.ORGANIZATION),
-        source: params.source,
-        sourceRef: params.sourceRef,
-      },
-      PlanTemplateRecordSchema,
-    )
-  }
-
-  async listTemplates(
-    organizationId: RecordIdInput,
-    params?: { tags?: string[]; source?: string },
-  ): Promise<PlanTemplateRecord[]> {
-    const filter: Record<string, unknown> = { organizationId: ensureRecordId(organizationId, TABLES.ORGANIZATION) }
-    if (params?.source) {
-      filter.source = params.source
-    }
-
-    const templates = await databaseService.findMany(TABLES.PLAN_TEMPLATE, filter, PlanTemplateRecordSchema, {
-      orderBy: 'createdAt',
-      orderDir: 'ASC',
-    })
-
-    if (params?.tags && params.tags.length > 0) {
-      const tagSet = new Set(params.tags)
-      return templates.filter((t) => t.tags.some((tag) => tagSet.has(tag)))
-    }
-
-    return templates
-  }
-
-  async updateTemplate(
-    templateId: RecordIdInput,
-    patch: Partial<{ name: string; description: string; draft: PlanDraft; tags: string[] }>,
-  ): Promise<PlanTemplateRecord> {
-    const updated = await databaseService.update(
-      TABLES.PLAN_TEMPLATE,
-      ensureRecordId(templateId, TABLES.PLAN_TEMPLATE),
-      patch,
-      PlanTemplateRecordSchema,
-    )
-    if (!updated) {
-      throw new Error(`Template not found: ${recordIdToString(templateId, TABLES.PLAN_TEMPLATE)}`)
-    }
-    return updated
-  }
-
-  async upsertTemplateBySourceRef(params: {
-    organizationId: RecordIdInput
-    name: string
-    description?: string
-    draft: PlanDraft
-    tags?: string[]
-    source: 'user' | 'playbook' | 'system'
-    sourceRef: string
-  }): Promise<PlanTemplateRecord> {
-    const existing = await this.getTemplateBySourceRef({
-      organizationId: params.organizationId,
-      source: params.source,
-      sourceRef: params.sourceRef,
-    })
-
-    if (!existing) {
-      return await this.createTemplate(params)
-    }
-
-    return await this.updateTemplate(existing.id, {
-      name: params.name,
-      description: params.description,
-      draft: params.draft,
-      tags: params.tags ?? [],
-    })
-  }
-
-  async deleteTemplate(templateId: RecordIdInput): Promise<void> {
-    await databaseService.deleteById(TABLES.PLAN_TEMPLATE, ensureRecordId(templateId, TABLES.PLAN_TEMPLATE))
-  }
-
-  async instantiate(params: {
-    templateId: RecordIdInput
-    organizationId: RecordIdInput
-    threadId: RecordIdInput
-    sourceThreadId?: RecordIdInput
-    leadAgentId: string
-    createdByAgentId?: string
-    requireApproval?: boolean
-    overrides?: Partial<PlanDraft>
-    carryForwardArtifacts?: PlanArtifactRecord[]
-  }): Promise<ExecutionPlanToolResultData> {
-    const template = await this.getTemplate(params.templateId)
-    if (!template) {
-      throw new Error(`Template not found: ${recordIdToString(params.templateId, TABLES.PLAN_TEMPLATE)}`)
-    }
-
-    const draft: PlanDraft = { ...template.draft, ...params.overrides }
-
-    if (params.carryForwardArtifacts && params.carryForwardArtifacts.length > 0) {
-      const carryContext = params.carryForwardArtifacts.map((a) => `[carry-forward] ${a.name}: ${a.pointer}`)
-      draft.objective = `${draft.objective}\n\nCarry-forward context:\n${carryContext.join('\n')}`
-    }
-
-    return executionPlanService.createPlan({
-      organizationId: params.organizationId,
-      threadId: params.threadId,
-      sourceThreadId: params.sourceThreadId,
-      leadAgentId: params.leadAgentId,
-      createdByAgentId: params.createdByAgentId,
-      requireApproval: params.requireApproval,
-      input: draft,
-    })
-  }
-}
-
-export const planTemplateService = new PlanTemplateService()