@lota-sdk/core 0.4.8 → 0.4.10

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

@@ -0,0 +1,131 @@
+import { Context, Effect, Layer, Schema } from 'effect'
+
+import { ServiceError } from '../../effect/errors'
+import { makeEffectTryPromiseWithMessage } from '../../effect/helpers'
+import { RedisServiceTag } from '../../effect/services'
+import { toValidationError } from '../../effect/zod'
+import type { RedisConnectionManager } from '../../redis/connection'
+import { nowEpochMillis } from '../../utils/date-time'
+
+const tryWorkspacePromise = makeEffectTryPromiseWithMessage((message, cause) => new ServiceError({ message, cause }))
+
+const PlanWorkspaceEntrySchema = Schema.Struct({
+  value: Schema.Unknown,
+  version: Schema.Number,
+  writeSequence: Schema.Number,
+  nodeId: Schema.String,
+  timestamp: Schema.Number,
+})
+
+const PlanWorkspaceEntryJsonSchema = Schema.fromJsonString(PlanWorkspaceEntrySchema)
+
+export type PlanWorkspaceEntry = {
+  value: unknown
+  version: number
+  writeSequence: number
+  nodeId: string
+  timestamp: number
+}
+
+const PLAN_WORKSPACE_KEY_PREFIX = 'plan-workspace:'
+
+function parsePlanWorkspaceEntryEffect(
+  fieldKey: string,
+  raw: string,
+): Effect.Effect<PlanWorkspaceEntry, ReturnType<typeof toValidationError>> {
+  return Schema.decodeUnknownEffect(PlanWorkspaceEntryJsonSchema)(raw).pipe(
+    Effect.mapError((error) => toValidationError(error, `Invalid plan workspace entry JSON for "${fieldKey}"`)),
+  )
+}
+
+export function makePlanWorkspaceService(redis: RedisConnectionManager) {
+  const writeEffect = (params: {
+    runId: string
+    nodeId: string
+    key: string
+    value: unknown
+    version: number
+    checkpointSequence: number
+  }) =>
+    Effect.gen(function* () {
+      const conn = redis.getConnection()
+      const hashKey = `${PLAN_WORKSPACE_KEY_PREFIX}${params.runId}`
+      const fieldKey = `${params.nodeId}:${params.key}`
+      const entry: PlanWorkspaceEntry = {
+        value: params.value,
+        version: params.version,
+        writeSequence: params.checkpointSequence,
+        nodeId: params.nodeId,
+        timestamp: nowEpochMillis(),
+      }
+      const serialized = yield* Schema.encodeEffect(PlanWorkspaceEntryJsonSchema)(entry)
+      yield* tryWorkspacePromise(
+        () => conn.hset(hashKey, fieldKey, serialized),
+        'Failed to write plan workspace entry.',
+      )
+    })
+
+  const snapshotReadEffect = (params: { runId: string; readerNodeId: string; snapshotSequence?: number }) =>
+    Effect.gen(function* () {
+      const conn = redis.getConnection()
+      const hashKey = `${PLAN_WORKSPACE_KEY_PREFIX}${params.runId}`
+      const nodePrefix = `${params.readerNodeId}:`
+      const all = yield* tryWorkspacePromise(() => conn.hgetall(hashKey), 'Failed to read plan workspace snapshot.')
+      const result: Record<string, PlanWorkspaceEntry> = {}
+      for (const [fieldKey, raw] of Object.entries(all)) {
+        if (!fieldKey.startsWith(nodePrefix)) continue
+        const entry = yield* parsePlanWorkspaceEntryEffect(fieldKey, raw)
+        if (params.snapshotSequence !== undefined && entry.writeSequence > params.snapshotSequence) {
+          continue
+        }
+        result[fieldKey] = entry
+      }
+      return result
+    })
+
+  const currentReadEffect = (params: { runId: string; key?: string }) =>
+    Effect.gen(function* () {
+      const conn = redis.getConnection()
+      const hashKey = `${PLAN_WORKSPACE_KEY_PREFIX}${params.runId}`
+      const key = params.key
+      if (key !== undefined) {
+        const raw = yield* tryWorkspacePromise(() => conn.hget(hashKey, key), 'Failed to read plan workspace entry.')
+        if (!raw) return {}
+        return { [key]: yield* parsePlanWorkspaceEntryEffect(key, raw) }
+      }
+      const all = yield* tryWorkspacePromise(() => conn.hgetall(hashKey), 'Failed to read plan workspace entries.')
+      const result: Record<string, PlanWorkspaceEntry> = {}
+      for (const [k, v] of Object.entries(all)) {
+        result[k] = yield* parsePlanWorkspaceEntryEffect(k, v)
+      }
+      return result
+    })
+
+  const cleanupEffect = (runId: string) =>
+    Effect.asVoid(
+      tryWorkspacePromise(() => {
+        const conn = redis.getConnection()
+        return conn.del(`${PLAN_WORKSPACE_KEY_PREFIX}${runId}`)
+      }, 'Failed to clean up plan workspace.'),
+    )
+
+  return {
+    write: writeEffect,
+    snapshotRead: snapshotReadEffect,
+    currentRead: currentReadEffect,
+    cleanup: cleanupEffect,
+  }
+}
+
+export class PlanWorkspaceServiceTag extends Context.Service<
+  PlanWorkspaceServiceTag,
+  ReturnType<typeof makePlanWorkspaceService>
+>()('@lota-sdk/core/PlanWorkspaceService') {}
+
+export const PlanWorkspaceServiceLive = Layer.effect(
+  PlanWorkspaceServiceTag,
+  Effect.gen(function* () {
+    const redis = yield* RedisServiceTag
+    return makePlanWorkspaceService(redis)
+  }),
+)

package/src/services/plugin-executor.service.ts

@@ -1,11 +1,21 @@
-import type { OwnershipDispatchContext, PlanNodeResult, PlanNodeSpec, PluginPlanNodeOwner } from '@lota-sdk/shared'
+import type { OwnershipDispatchContext, PlanNodeSpec, PluginPlanNodeOwner } from '@lota-sdk/shared'
+import { Context, Effect, Layer } from 'effect'
 
+import { BadRequestError, ServiceError } from '../effect/errors'
+import { makeEffectTryPromiseWithMessage } from '../effect/helpers'
+import { RuntimeConfigServiceTag } from '../effect/services'
+
+const tryPluginExecutorPromise = makeEffectTryPromiseWithMessage(
+  (message, cause) => new ServiceError({ message, cause }),
+)
 import type { LotaPlugin, PluginNodeExecutionParams } from '../runtime/plugin-types'
-import { getRuntimeConfig } from '../runtime/runtime-config'
-import type { PlanValidationIssueInput } from './plan-validator.service'
+import type { ResolvedLotaRuntimeConfig } from '../runtime/runtime-config'
+import type { PlanValidationIssueInput } from './plan/plan-validator.service'
 
-function getPluginRuntime() {
-  return (getRuntimeConfig().pluginRuntime ?? {}) as Record<string, LotaPlugin | undefined>
+function isPluginOwner(
+  owner: PlanNodeSpec['owner'],
+): owner is Extract<PlanNodeSpec['owner'], { executorType: 'plugin' }> {
+  return owner.executorType === 'plugin'
 }
 
 function buildPluginExecutionParams(params: {
@@ -29,75 +39,99 @@ function buildPluginExecutionParams(params: {
   }
 }
 
-class PluginExecutorService {
-  validateOwner(owner: PluginPlanNodeOwner, nodeId: string): PlanValidationIssueInput[] {
-    const plugin = getPluginRuntime()[owner.ref]
-    if (!plugin) {
-      return [
-        {
-          severity: 'blocking',
-          code: 'plugin_executor_missing',
-          message: `Node "${nodeId}" references unknown plugin executor "${owner.ref}".`,
-          nodeId,
-          detail: { pluginRef: owner.ref },
-        },
-      ]
-    }
+export function makePluginExecutorService(config: ResolvedLotaRuntimeConfig) {
+  function getPluginRuntime() {
+    return (config.pluginRuntime ?? {}) as Record<string, LotaPlugin | undefined>
+  }
 
-    const nodeExecutor = plugin.nodeExecutor
-    if (!nodeExecutor) {
-      return [
-        {
-          severity: 'blocking',
-          code: 'plugin_node_executor_missing',
-          message: `Plugin "${owner.ref}" does not expose a node executor.`,
-          nodeId,
-          detail: { pluginRef: owner.ref },
-        },
-      ]
-    }
+  return {
+    validateOwner(owner: PluginPlanNodeOwner, nodeId: string): PlanValidationIssueInput[] {
+      const plugin = getPluginRuntime()[owner.ref]
+      if (!plugin) {
+        return [
+          {
+            severity: 'blocking',
+            code: 'plugin_executor_missing',
+            message: `Node "${nodeId}" references unknown plugin executor "${owner.ref}".`,
+            nodeId,
+            detail: { pluginRef: owner.ref },
+          },
+        ]
+      }
 
-    if (!nodeExecutor.supportedOperations.includes(owner.operation)) {
-      return [
-        {
-          severity: 'blocking',
-          code: 'plugin_operation_missing',
-          message: `Plugin "${owner.ref}" does not support operation "${owner.operation}".`,
-          nodeId,
-          detail: { pluginRef: owner.ref, operation: owner.operation },
-        },
-      ]
-    }
+      const nodeExecutor = plugin.nodeExecutor
+      if (!nodeExecutor) {
+        return [
+          {
+            severity: 'blocking',
+            code: 'plugin_node_executor_missing',
+            message: `Plugin "${owner.ref}" does not expose a node executor.`,
+            nodeId,
+            detail: { pluginRef: owner.ref },
+          },
+        ]
+      }
 
-    return []
-  }
+      if (!nodeExecutor.supportedOperations.includes(owner.operation)) {
+        return [
+          {
+            severity: 'blocking',
+            code: 'plugin_operation_missing',
+            message: `Plugin "${owner.ref}" does not support operation "${owner.operation}".`,
+            nodeId,
+            detail: { pluginRef: owner.ref, operation: owner.operation },
+          },
+        ]
+      }
 
-  async executeNode(params: {
-    nodeSpec: PlanNodeSpec
-    resolvedInput: Record<string, unknown>
-    context: OwnershipDispatchContext
-  }): Promise<PlanNodeResult> {
-    if (params.nodeSpec.owner.executorType !== 'plugin') {
-      throw new Error(`PluginExecutor cannot execute owner type "${params.nodeSpec.owner.executorType}".`)
-    }
+      return []
+    },
+
+    executeNode: Effect.fn('PluginExecutor.executeNode')(function* (params: {
+      nodeSpec: PlanNodeSpec
+      resolvedInput: Record<string, unknown>
+      context: OwnershipDispatchContext
+    }) {
+      const owner = params.nodeSpec.owner
+      if (!isPluginOwner(owner)) {
+        return yield* new BadRequestError({
+          message: `PluginExecutor cannot execute owner type "${owner.executorType}".`,
+        })
+      }
 
-    const plugin = getPluginRuntime()[params.nodeSpec.owner.ref]
-    const nodeExecutor = plugin?.nodeExecutor
-    if (!plugin || !nodeExecutor || !nodeExecutor.supportedOperations.includes(params.nodeSpec.owner.operation)) {
-      throw new Error(
-        `Plugin executor ${params.nodeSpec.owner.ref}.${params.nodeSpec.owner.operation} is not registered.`,
-      )
-    }
+      const plugin = getPluginRuntime()[owner.ref]
+      const nodeExecutor = plugin?.nodeExecutor
+      if (!plugin || !nodeExecutor || !nodeExecutor.supportedOperations.includes(owner.operation)) {
+        return yield* new BadRequestError({
+          message: `Plugin executor ${owner.ref}.${owner.operation} is not registered.`,
+        })
+      }
 
-    return nodeExecutor.executeNode(
-      buildPluginExecutionParams({
-        owner: params.nodeSpec.owner,
-        nodeSpec: params.nodeSpec,
-        resolvedInput: params.resolvedInput,
-        context: params.context,
-      }),
-    )
+      return yield* tryPluginExecutorPromise(
+        () =>
+          nodeExecutor.executeNode(
+            buildPluginExecutionParams({
+              owner,
+              nodeSpec: params.nodeSpec,
+              resolvedInput: params.resolvedInput,
+              context: params.context,
+            }),
+          ),
+        `Plugin executor "${owner.ref}.${owner.operation}" failed.`,
+      ).pipe(Effect.withSpan('PluginExecutor.invoke'))
+    }),
   }
 }
 
-export const pluginExecutorService = new PluginExecutorService()
+export class PluginExecutorServiceTag extends Context.Service<
+  PluginExecutorServiceTag,
+  ReturnType<typeof makePluginExecutorService>
+>()('@lota-sdk/core/PluginExecutorService') {}
+
+export const PluginExecutorServiceLive = Layer.effect(
+  PluginExecutorServiceTag,
+  Effect.gen(function* () {
+    const runtimeConfig = yield* RuntimeConfigServiceTag
+    return makePluginExecutorService(runtimeConfig)
+  }),
+)

package/src/services/quality-metrics.service.ts

@@ -1,10 +1,12 @@
 import { NodeQualityMetricsSchema } from '@lota-sdk/shared'
 import type { NodeQualityMetrics } from '@lota-sdk/shared'
+import { Context, Effect, Layer } from 'effect'
 import { z } from 'zod'
 
 import { ensureRecordId } from '../db/record-id'
-import { databaseService } from '../db/service'
+import type { SurrealDBService } from '../db/service'
 import { TABLES } from '../db/tables'
+import { DatabaseServiceTag } from '../effect/services'
 
 const QualityMetricRowSchema = NodeQualityMetricsSchema.extend({
   id: z.unknown(),
@@ -15,118 +17,134 @@ const QualityMetricRowSchema = NodeQualityMetricsSchema.extend({
   updatedAt: z.coerce.date().optional(),
 })
 
-class QualityMetricsService {
-  async recordNodeMetrics(params: {
+export function makeQualityMetricsService(db: SurrealDBService) {
+  const recordNodeMetricsEffect = (params: {
     organizationId: string
     runId: string
     nodeId: string
     metrics: NodeQualityMetrics
-  }): Promise<void> {
-    await databaseService.create(
-      TABLES.QUALITY_METRIC,
-      {
-        organizationId: ensureRecordId(params.organizationId, TABLES.ORGANIZATION),
-        runId: ensureRecordId(params.runId, TABLES.PLAN_RUN),
-        nodeId: params.nodeId,
-        ownerRef: params.metrics.ownerRef,
-        ownerType: params.metrics.ownerType,
-        nodeType: params.metrics.nodeType,
-        executionTimeMs: params.metrics.executionTimeMs,
-        attemptCount: params.metrics.attemptCount,
-        artifactCount: params.metrics.artifactCount,
-        validationIssueCount: params.metrics.validationIssueCount,
-      },
-      QualityMetricRowSchema,
-    )
-  }
-
-  async recordCycleMetrics(params: { organizationId: string; runId: string }): Promise<void> {
-    const existing = await databaseService.findMany(
-      TABLES.QUALITY_METRIC,
-      { runId: ensureRecordId(params.runId, TABLES.PLAN_RUN) },
-      QualityMetricRowSchema,
-      { orderBy: 'createdAt', orderDir: 'ASC' },
-    )
-
-    if (!Array.isArray(existing) || existing.length === 0) return
-
-    const totalExecutionTime = existing.reduce(
-      (sum, m) => sum + (typeof m.executionTimeMs === 'number' ? m.executionTimeMs : 0),
-      0,
-    )
-    const totalAttempts = existing.reduce(
-      (sum, m) => sum + (typeof m.attemptCount === 'number' ? m.attemptCount : 0),
-      0,
-    )
-    const totalIssues = existing.reduce(
-      (sum, m) => sum + (typeof m.validationIssueCount === 'number' ? m.validationIssueCount : 0),
-      0,
+  }) =>
+    Effect.asVoid(
+      db.create(
+        TABLES.QUALITY_METRIC,
+        {
+          organizationId: ensureRecordId(params.organizationId, TABLES.ORGANIZATION),
+          runId: ensureRecordId(params.runId, TABLES.PLAN_RUN),
+          nodeId: params.nodeId,
+          ownerRef: params.metrics.ownerRef,
+          ownerType: params.metrics.ownerType,
+          nodeType: params.metrics.nodeType,
+          executionTimeMs: params.metrics.executionTimeMs,
+          attemptCount: params.metrics.attemptCount,
+          artifactCount: params.metrics.artifactCount,
+          validationIssueCount: params.metrics.validationIssueCount,
+        },
+        QualityMetricRowSchema,
+      ),
     )
 
-    await databaseService.create(
+  const recordCycleMetricsEffect = (params: { organizationId: string; runId: string }) =>
+    Effect.gen(function* () {
+      const existing = yield* db.findMany(
+        TABLES.QUALITY_METRIC,
+        { runId: ensureRecordId(params.runId, TABLES.PLAN_RUN) },
+        QualityMetricRowSchema,
+        { orderBy: 'createdAt', orderDir: 'ASC' },
+      )
+
+      if (!Array.isArray(existing) || existing.length === 0) return
+
+      const totalExecutionTime = existing.reduce(
+        (sum, m) => sum + (typeof m.executionTimeMs === 'number' ? m.executionTimeMs : 0),
+        0,
+      )
+      const totalAttempts = existing.reduce(
+        (sum, m) => sum + (typeof m.attemptCount === 'number' ? m.attemptCount : 0),
+        0,
+      )
+      const totalIssues = existing.reduce(
+        (sum, m) => sum + (typeof m.validationIssueCount === 'number' ? m.validationIssueCount : 0),
+        0,
+      )
+
+      yield* Effect.asVoid(
+        db.create(
+          TABLES.QUALITY_METRIC,
+          {
+            organizationId: ensureRecordId(params.organizationId, TABLES.ORGANIZATION),
+            runId: ensureRecordId(params.runId, TABLES.PLAN_RUN),
+            ownerRef: 'cycle-summary',
+            ownerType: 'system',
+            nodeType: 'action',
+            executionTimeMs: totalExecutionTime,
+            attemptCount: totalAttempts,
+            artifactCount: existing.length,
+            validationIssueCount: totalIssues,
+          },
+          QualityMetricRowSchema,
+        ),
+      )
+    })
+
+  const getMetricsByOwnerEffect = (params: { organizationId: string; ownerRef: string; limit?: number }) =>
+    db.findMany(
       TABLES.QUALITY_METRIC,
-      {
-        organizationId: ensureRecordId(params.organizationId, TABLES.ORGANIZATION),
-        runId: ensureRecordId(params.runId, TABLES.PLAN_RUN),
-        ownerRef: 'cycle-summary',
-        ownerType: 'system',
-        nodeType: 'action',
-        executionTimeMs: totalExecutionTime,
-        attemptCount: totalAttempts,
-        artifactCount: existing.length,
-        validationIssueCount: totalIssues,
-      },
+      { organizationId: ensureRecordId(params.organizationId, TABLES.ORGANIZATION), ownerRef: params.ownerRef },
       QualityMetricRowSchema,
+      { orderBy: 'createdAt', orderDir: 'DESC', limit: params.limit ?? 20 },
     )
-  }
 
-  detectRegression(params: {
-    metrics: Array<{ executionTimeMs: number; validationIssueCount: number }>
-    window?: number
-  }): { detected: boolean; trend?: 'improving' | 'stable' | 'regressing' } {
-    const window = params.window ?? 5
-    const recent = params.metrics.slice(-window)
-    if (recent.length < 2) return { detected: false, trend: 'stable' }
+  return {
+    recordNodeMetrics: recordNodeMetricsEffect,
+    recordCycleMetrics: recordCycleMetricsEffect,
+    getMetricsByOwner: getMetricsByOwnerEffect,
 
-    const mid = Math.floor(recent.length / 2)
-    const firstHalf = recent.slice(0, mid)
-    const secondHalf = recent.slice(mid)
+    detectRegression(params: {
+      metrics: Array<{ executionTimeMs: number; validationIssueCount: number }>
+      window?: number
+    }): { detected: boolean; trend?: 'improving' | 'stable' | 'regressing' } {
+      const window = params.window ?? 5
+      const recent = params.metrics.slice(-window)
+      if (recent.length < 2) return { detected: false, trend: 'stable' }
 
-    const avgFirst = firstHalf.reduce((sum, m) => sum + m.validationIssueCount, 0) / firstHalf.length
-    const avgSecond = secondHalf.reduce((sum, m) => sum + m.validationIssueCount, 0) / secondHalf.length
+      const mid = Math.floor(recent.length / 2)
+      const firstHalf = recent.slice(0, mid)
+      const secondHalf = recent.slice(mid)
 
-    const timeFirst = firstHalf.reduce((sum, m) => sum + m.executionTimeMs, 0) / firstHalf.length
-    const timeSecond = secondHalf.reduce((sum, m) => sum + m.executionTimeMs, 0) / secondHalf.length
+      const avgFirst = firstHalf.reduce((sum, m) => sum + m.validationIssueCount, 0) / firstHalf.length
+      const avgSecond = secondHalf.reduce((sum, m) => sum + m.validationIssueCount, 0) / secondHalf.length
 
-    const issueRegression = avgFirst > 0 && avgSecond > avgFirst * 1.5
-    const timeRegression = timeFirst > 0 && timeSecond > timeFirst * 2
+      const timeFirst = firstHalf.reduce((sum, m) => sum + m.executionTimeMs, 0) / firstHalf.length
+      const timeSecond = secondHalf.reduce((sum, m) => sum + m.executionTimeMs, 0) / secondHalf.length
 
-    if (issueRegression || timeRegression) {
-      return { detected: true, trend: 'regressing' }
-    }
+      const issueRegression = avgFirst > 0 && avgSecond > avgFirst * 1.5
+      const timeRegression = timeFirst > 0 && timeSecond > timeFirst * 2
 
-    const issueImproving = avgFirst > 0 && avgSecond < avgFirst * 0.7
-    const timeImproving = timeFirst > 0 && timeSecond < timeFirst * 0.7
+      if (issueRegression || timeRegression) {
+        return { detected: true, trend: 'regressing' }
+      }
 
-    if (issueImproving || timeImproving) {
-      return { detected: false, trend: 'improving' }
-    }
+      const issueImproving = avgFirst > 0 && avgSecond < avgFirst * 0.7
+      const timeImproving = timeFirst > 0 && timeSecond < timeFirst * 0.7
 
-    return { detected: false, trend: 'stable' }
-  }
+      if (issueImproving || timeImproving) {
+        return { detected: false, trend: 'improving' }
+      }
 
-  async getMetricsByOwner(params: {
-    organizationId: string
-    ownerRef: string
-    limit?: number
-  }): Promise<z.infer<typeof QualityMetricRowSchema>[]> {
-    return databaseService.findMany(
-      TABLES.QUALITY_METRIC,
-      { organizationId: ensureRecordId(params.organizationId, TABLES.ORGANIZATION), ownerRef: params.ownerRef },
-      QualityMetricRowSchema,
-      { orderBy: 'createdAt', orderDir: 'DESC', limit: params.limit ?? 20 },
-    )
+      return { detected: false, trend: 'stable' }
+    },
   }
 }
 
-export const qualityMetricsService = new QualityMetricsService()
+export class QualityMetricsServiceTag extends Context.Service<
+  QualityMetricsServiceTag,
+  ReturnType<typeof makeQualityMetricsService>
+>()('@lota-sdk/core/QualityMetricsService') {}
+
+export const QualityMetricsServiceLive = Layer.effect(
+  QualityMetricsServiceTag,
+  Effect.gen(function* () {
+    const db = yield* DatabaseServiceTag
+    return makeQualityMetricsService(db)
+  }),
+)