@lota-sdk/core 0.4.8 → 0.4.9

package/src/runtime/indexed-repositories-policy.ts

@@ -1,4 +1,4 @@
-import { agentRoster } from '../config/agent-defaults'
+import { getAgentRoster } from '../config/agent-defaults'
 
 export type IndexedRepoAgentName = string
 
@@ -16,13 +16,13 @@ export type RepoSectionName = (typeof REPO_SECTION_NAMES)[number]
 const ALL_REPO_SECTIONS: RepoSectionName[] = [...REPO_SECTION_NAMES]
 
 export function buildDefaultRepoSectionsByAgent(
-  roster: readonly IndexedRepoAgentName[] = agentRoster,
+  roster: readonly IndexedRepoAgentName[] = getAgentRoster(),
 ): Record<IndexedRepoAgentName, RepoSectionName[]> {
   return Object.fromEntries(roster.map((agentId) => [agentId, [...ALL_REPO_SECTIONS]]))
 }
 
 export function emptyAgentContextMap(
-  roster: readonly IndexedRepoAgentName[] = agentRoster,
+  roster: readonly IndexedRepoAgentName[] = getAgentRoster(),
 ): Record<IndexedRepoAgentName, string> {
   return Object.fromEntries(roster.map((agentId) => [agentId, '']))
 }

package/src/runtime/{memory-block.ts → memory/memory-block.ts}

@@ -1,31 +1,30 @@
+import type { Cause } from 'effect'
+import { DateTime, Effect } from 'effect'
 import { z } from 'zod'
 
-import { agentDisplayNames, agentShortDisplayNames, resolveAgentNameAlias } from '../config/agent-defaults'
-import { compactWhitespace } from '../utils/string'
+import { effectTryPromise } from '../../effect/helpers'
+import { compactWhitespace } from '../../utils/string'
 
 function escapeRegex(value: string): string {
   return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
 }
 
 function normalizeMemoryBlockRole(role: string): string {
-  const canonicalRole = resolveAgentNameAlias(role)
-  if (canonicalRole) return canonicalRole
   return role.trim().toLowerCase()
 }
 
+function toLabelAlias(role: string): string {
+  const trimmed = role.trim()
+  if (!trimmed) return ''
+  return trimmed.length === 1 ? trimmed.toUpperCase() : `${trimmed[0].toUpperCase()}${trimmed.slice(1).toLowerCase()}`
+}
+
 function getMemoryBlockRoleAliases(role: string): string[] {
   const normalizedRole = role.trim()
   if (!normalizedRole) return []
-
-  const canonicalRole = resolveAgentNameAlias(normalizedRole)
-  if (!canonicalRole) return [normalizedRole]
-
-  return [
-    normalizedRole,
-    canonicalRole,
-    agentDisplayNames[canonicalRole],
-    agentShortDisplayNames[canonicalRole],
-  ].filter((value): value is string => typeof value === 'string' && value.trim().length > 0)
+  return [normalizedRole, normalizedRole.toLowerCase(), toLabelAlias(normalizedRole)].filter(
+    (value): value is string => typeof value === 'string' && value.trim().length > 0,
+  )
 }
 
 function createLabelPrefixRegex(labelRoles: readonly string[]): RegExp | null {
@@ -59,7 +58,10 @@ export interface CompactMemoryBlockEntriesParams {
   entries: MemoryBlockEntry[]
   triggerEntries: number
   chunkEntries: number
-  compact: (params: { previousSummary: string; newEntriesText: string }) => Promise<string>
+  compact: (params: {
+    previousSummary: string
+    newEntriesText: string
+  }) => PromiseLike<string> | Effect.Effect<string, unknown>
 }
 
 export interface CompactMemoryBlockEntriesResult {
@@ -102,29 +104,31 @@ function toMemoryBlockEntriesSource(entries: Array<{ role: string; content: stri
   return entries.map((entry) => `${entry.role}: ${entry.content}`).join('\n')
 }
 
-export async function compactMemoryBlockEntries(
+export function compactMemoryBlockEntries(
   params: CompactMemoryBlockEntriesParams,
-): Promise<CompactMemoryBlockEntriesResult> {
-  let summary = typeof params.previousSummary === 'string' ? params.previousSummary.trim() : ''
-  let entries = [...params.entries]
-  let compacted = false
-
-  while (entries.length >= params.triggerEntries) {
-    const chunk = entries.slice(0, params.chunkEntries)
-    const nextSummary = (
-      await params.compact({ previousSummary: summary, newEntriesText: toMemoryBlockEntriesSource(chunk) })
-    ).trim()
-
-    if (!nextSummary) {
-      break
+): Effect.Effect<CompactMemoryBlockEntriesResult, Cause.UnknownError> {
+  return Effect.gen(function* () {
+    let summary = typeof params.previousSummary === 'string' ? params.previousSummary.trim() : ''
+    let entries = [...params.entries]
+    let compacted = false
+
+    while (entries.length >= params.triggerEntries) {
+      const chunk = entries.slice(0, params.chunkEntries)
+      const nextSummary = (yield* effectTryPromise(() =>
+        params.compact({ previousSummary: summary, newEntriesText: toMemoryBlockEntriesSource(chunk) }),
+      )).trim()
+
+      if (!nextSummary) {
+        break
+      }
+
+      summary = nextSummary
+      entries = entries.slice(params.chunkEntries)
+      compacted = true
     }
 
-    summary = nextSummary
-    entries = entries.slice(params.chunkEntries)
-    compacted = true
-  }
-
-  return { compacted, summary, entries }
+    return { compacted, summary, entries }
+  })
 }
 
 export function prepareMemoryBlockAppend(params: PrepareMemoryBlockAppendParams): PrepareMemoryBlockAppendResult {
@@ -158,7 +162,7 @@ export interface CreateMemoryBlockRuntimeOptions {
 export function createMemoryBlockRuntime(options: CreateMemoryBlockRuntimeOptions = {}): MemoryBlockRuntime {
   const labelPrefixRegex = createLabelPrefixRegex(options.labelRoles ?? [])
   const memoryBlockMaxChars = options.maxChars ?? 400
-  const now = options.now ?? (() => new Date())
+  const now = options.now ?? (() => Effect.runSync(DateTime.nowAsDate))
 
   const normalizeMemoryBlockEntry = (entry: string): string => {
     const normalizedLines = entry

package/src/runtime/{memory-digest-policy.ts → memory/memory-digest-policy.ts}

@@ -1,4 +1,4 @@
-import { getBackgroundProcessingConfig, shouldRunAtFrequency } from '../config/background-processing'
+import { getBackgroundProcessingConfig, shouldRunAtFrequency } from '../../config/background-processing'
 
 export function shouldEnqueueOnboardingPostChatMemory(params: {
   onboardingActive: boolean

package/src/runtime/{memory-pipeline.ts → memory/memory-pipeline.ts}

@@ -1,4 +1,4 @@
-import { clampImportance, compactWhitespace } from '../utils/string'
+import { clampImportance, compactWhitespace } from '../../utils/string'
 
 const SCORE_WEIGHTS = {
   durability: { core: 0.35, standard: 0.2, weak: 0.05 },

package/src/runtime/{memory-prompts-fact.ts → memory/memory-prompts-fact.ts}

@@ -1,4 +1,4 @@
-import { formatUtcPromptDate } from '../utils/date-time'
+import { formatUtcPromptDate, nowDate } from '../../utils/date-time'
 
 export function getFactRetrievalMessages(
   parsedMessages: string,
@@ -56,7 +56,7 @@ Hard rules:
 - Prefer returning fewer items. If uncertain, return an empty list.
 - Max ${maxFacts} facts.
 
-Today's date is ${formatUtcPromptDate(new Date())}.
+Today's date is ${formatUtcPromptDate(nowDate())}.
 ${baseInstructions}`
 
   const userPrompt = `Conversation:\n${parsedMessages}`

package/src/runtime/{memory-scope.ts → memory/memory-scope.ts}

@@ -1,11 +1,17 @@
+import { Schema } from 'effect'
+
 export const ORG_SCOPE_PREFIX = 'org'
 
 const SCOPE_ID_MAX_LENGTH = 255
 const SCOPE_PREFIX_REGEX = /^[a-z][a-z0-9_]*$/
 
+export class MemoryScopeError extends Schema.TaggedErrorClass<MemoryScopeError>()('MemoryScopeError', {
+  message: Schema.String,
+}) {}
+
 function stripRecordPrefix(id: string): string {
   if (typeof id !== 'string' || id.length === 0) {
-    throw new TypeError('id must be a non-empty string')
+    throw new MemoryScopeError({ message: 'id must be a non-empty string' })
   }
   const [, ...rest] = id.split(':')
   return rest.length > 0 ? rest.join(':') : id
@@ -13,16 +19,16 @@ function stripRecordPrefix(id: string): string {
 
 export function scopeId(prefix: string, id: string): string {
   if (typeof prefix !== 'string' || prefix.length === 0) {
-    throw new TypeError('prefix must be a non-empty string')
+    throw new MemoryScopeError({ message: 'prefix must be a non-empty string' })
   }
   if (!SCOPE_PREFIX_REGEX.test(prefix)) {
-    throw new Error(`Invalid scope prefix: ${prefix}`)
+    throw new MemoryScopeError({ message: `Invalid scope prefix: ${prefix}` })
   }
 
   const stripped = stripRecordPrefix(id)
   const scoped = `${prefix}:${stripped}`
   if (scoped.length > SCOPE_ID_MAX_LENGTH) {
-    throw new Error('scopeId exceeds maximum length')
+    throw new MemoryScopeError({ message: 'scopeId exceeds maximum length' })
   }
 
   return scoped
@@ -30,13 +36,13 @@ export function scopeId(prefix: string, id: string): string {
 
 export function agentScopeId(orgId: string, agentName: string): string {
   if (typeof agentName !== 'string' || agentName.trim().length === 0) {
-    throw new TypeError('agentName must be a non-empty string')
+    throw new MemoryScopeError({ message: 'agentName must be a non-empty string' })
   }
   const strippedOrgId = stripRecordPrefix(orgId)
   const scoped = `agent:${strippedOrgId}:${agentName.trim()}`
 
   if (scoped.length > SCOPE_ID_MAX_LENGTH) {
-    throw new Error('scopeId exceeds maximum length')
+    throw new MemoryScopeError({ message: 'scopeId exceeds maximum length' })
   }
 
   return scoped

package/src/runtime/plugin-resolution.ts

@@ -1,36 +1,156 @@
-import { pluginRuntime } from '../config/agent-defaults'
+import { Schema, Effect } from 'effect'
+
+import { getPluginRuntime } from '../config/agent-defaults'
+import type { RecordIdRef } from '../db/record-id'
 import type { LotaRuntimeIndexedRepositoriesContext } from './runtime-extensions'
 import { getRuntimeAdapters } from './runtime-extensions'
 
-export function getPluginService(path: string[]): ((...args: unknown[]) => unknown) | undefined {
-  let current: unknown = pluginRuntime
-  let owner: unknown = undefined
-  for (const key of path) {
-    if (current === null || current === undefined || typeof current !== 'object') return undefined
-    owner = current
-    current = (current as Record<string, unknown>)[key]
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === 'object' && value !== null
+}
+
+class PluginResolutionError extends Schema.TaggedErrorClass<PluginResolutionError>()('PluginResolutionError', {
+  stage: Schema.Literals([
+    'configuration',
+    'linear-installation',
+    'github-installation',
+    'indexed-repositories-context',
+  ]),
+  message: Schema.String,
+  cause: Schema.Defect,
+}) {}
+
+function toPluginResolutionError(stage: PluginResolutionError['stage'], cause: unknown): PluginResolutionError {
+  return new PluginResolutionError({ stage, message: cause instanceof Error ? cause.message : String(cause), cause })
+}
+
+function readFunctionEffect(
+  value: unknown,
+  errorMessage: string,
+): Effect.Effect<(...args: unknown[]) => PromiseLike<unknown>, PluginResolutionError> {
+  if (typeof value !== 'function') {
+    return Effect.fail(new PluginResolutionError({ stage: 'configuration', message: errorMessage, cause: undefined }))
+  }
+
+  return Effect.succeed(value as (...args: unknown[]) => PromiseLike<unknown>)
+}
+
+function resolvePluginServiceEffect(
+  pluginName: string,
+  serviceName: string,
+  methodName: string,
+): Effect.Effect<(...args: unknown[]) => PromiseLike<unknown>, PluginResolutionError> {
+  const pluginRuntime = getPluginRuntime()
+  if (!pluginRuntime) {
+    return Effect.fail(
+      new PluginResolutionError({
+        stage: 'configuration',
+        message: `Plugin runtime is not configured. Missing "${pluginName}" integration.`,
+        cause: undefined,
+      }),
+    )
+  }
+
+  const plugin = pluginRuntime[pluginName]
+  if (!isRecord(plugin)) {
+    return Effect.fail(
+      new PluginResolutionError({
+        stage: 'configuration',
+        message: `Plugin "${pluginName}" is not configured in the current runtime.`,
+        cause: undefined,
+      }),
+    )
+  }
+
+  const services = plugin.services
+  if (!isRecord(services)) {
+    return Effect.fail(
+      new PluginResolutionError({
+        stage: 'configuration',
+        message: `Plugin "${pluginName}" does not expose a services registry.`,
+        cause: undefined,
+      }),
+    )
   }
-  if (typeof current !== 'function') {
-    return undefined
+
+  const service = services[serviceName]
+  if (!isRecord(service)) {
+    return Effect.fail(
+      new PluginResolutionError({
+        stage: 'configuration',
+        message: `Plugin "${pluginName}" service "${serviceName}" is not configured.`,
+        cause: undefined,
+      }),
+    )
   }
 
-  return owner && typeof owner === 'object'
-    ? (current as (...args: unknown[]) => unknown).bind(owner)
-    : (current as (...args: unknown[]) => unknown)
+  return readFunctionEffect(
+    service[methodName],
+    `Plugin "${pluginName}" service "${serviceName}" is missing method "${methodName}".`,
+  ).pipe(
+    Effect.map(
+      (method) =>
+        (...args: unknown[]) =>
+          Reflect.apply(method, service, args),
+    ),
+  )
+}
+
+function tryResolvePluginServiceEffect(
+  pluginName: string,
+  serviceName: string,
+  methodName: string,
+): Effect.Effect<((...args: unknown[]) => PromiseLike<unknown>) | undefined> {
+  return Effect.catch(resolvePluginServiceEffect(pluginName, serviceName, methodName), () => Effect.succeed(undefined))
 }
 
-export async function buildIndexedRepositoriesContext(
+export function getLinearInstallationByOrgId(organizationId: RecordIdRef): Promise<unknown> {
+  return Effect.runPromise(
+    Effect.gen(function* () {
+      const fn = yield* tryResolvePluginServiceEffect('linear', 'linearService', 'getInstallationByOrgId')
+      if (!fn) return null
+      return yield* Effect.tryPromise({
+        try: () => fn(organizationId),
+        catch: (cause) => toPluginResolutionError('linear-installation', cause),
+      })
+    }),
+  )
+}
+
+export function getGithubInstallationForOrganization(organizationId: string): Promise<unknown> {
+  return Effect.runPromise(
+    Effect.gen(function* () {
+      const fn = yield* tryResolvePluginServiceEffect('github', 'githubService', 'getInstallationForOrganization')
+      if (!fn) return null
+      return yield* Effect.tryPromise({
+        try: () => fn(organizationId),
+        catch: (cause) => toPluginResolutionError('github-installation', cause),
+      })
+    }),
+  )
+}
+
+const EMPTY_INDEXED_REPO_CONTEXT: LotaRuntimeIndexedRepositoriesContext = {
+  provideRepoTool: false,
+  defaultSectionsByAgent: {},
+  context: '',
+}
+
+export function buildIndexedRepositoriesContext(
   organizationId: string,
 ): Promise<LotaRuntimeIndexedRepositoriesContext> {
   const buildContext = getRuntimeAdapters().buildIndexedRepositoriesContext
-  if (!buildContext) {
-    return { provideRepoTool: false, defaultSectionsByAgent: {}, context: '' }
-  }
-
-  const result = await buildContext(organizationId)
-  return {
-    provideRepoTool: result.provideRepoTool,
-    defaultSectionsByAgent: result.defaultSectionsByAgent,
-    context: result.context ?? '',
-  }
+  if (!buildContext) return Promise.resolve(EMPTY_INDEXED_REPO_CONTEXT)
+  return Effect.runPromise(
+    Effect.tryPromise({
+      try: () => buildContext(organizationId),
+      catch: (cause) => toPluginResolutionError('indexed-repositories-context', cause),
+    }).pipe(
+      Effect.map((result) => ({
+        provideRepoTool: result.provideRepoTool,
+        defaultSectionsByAgent: result.defaultSectionsByAgent,
+        context: result.context ?? '',
+      })),
+    ),
+  )
 }

package/src/runtime/plugin-types.ts

@@ -33,7 +33,15 @@ export interface SystemNodeExecutor {
   executeNode(params: PluginNodeExecutionParams): Promise<PlanNodeResult>
 }
 
-export interface LotaPlugin<TServices = Record<string, unknown>, TTools = Record<string, unknown>> {
+export interface PluginLifecycleServices {
+  connectDatabase?(): Promise<void>
+  disconnectDatabase?(): Promise<void>
+}
+
+export interface LotaPlugin<
+  TServices extends Record<string, unknown> = Record<string, unknown>,
+  TTools = Record<string, unknown>,
+> {
   services: TServices
   nodeExecutor?: PluginNodeExecutor
   tools?: TTools