@pikku/core 0.12.107 → 0.12.111

package/src/services/meta-service.ts

@@ -1,767 +0,0 @@
-import { readFile, readdir } from 'node:fs/promises'
-import { existsSync } from 'node:fs'
-import { createRequire } from 'node:module'
-import { join } from 'node:path'
-import type { JSONSchema7 } from 'json-schema'
-import type { HTTPWiringsMeta } from '../wirings/http/http.types.js'
-import type { ChannelsMeta } from '../wirings/channel/channel.types.js'
-import type { ScheduledTasksMeta } from '../wirings/scheduler/scheduler.types.js'
-import type { QueueWorkersMeta } from '../wirings/queue/queue.types.js'
-import type { CLIMeta } from '../wirings/cli/cli.types.js'
-import type {
-  MCPResourceMeta,
-  MCPToolMeta,
-  MCPPromptMeta,
-} from '../wirings/mcp/mcp.types.js'
-import type { WorkflowsMeta } from '../wirings/workflow/workflow.types.js'
-import type { FeaturesMeta } from '../wirings/workflow/scenario.types.js'
-import type { ResolvedPersona } from './personas-service.js'
-import type { SystemRoleDefinitionsMeta } from '../wirings/role/role.types.js'
-import type {
-  TriggerMeta,
-  TriggerSourceMeta,
-} from '../wirings/trigger/trigger.types.js'
-import type { SecretDefinitionsMeta } from '../wirings/secret/secret.types.js'
-import type { CredentialDefinitionsMeta } from '../wirings/credential/credential.types.js'
-import type { VariableDefinitionsMeta } from '../wirings/variable/variable.types.js'
-import type {
-  FunctionMeta,
-  FunctionsMeta,
-  PermissionMetadata,
-} from '../function/function-meta.types.js'
-import type { MiddlewareMetadata } from '../middleware/middleware.types.js'
-import type { AgentsMeta } from '../wirings/agent/agent.types.js'
-import type { GatewaysMeta } from '../wirings/gateway/gateway.types.js'
-
-export type {
-  FunctionMeta,
-  FunctionsMeta,
-  MiddlewareMetadata as MiddlewareMeta,
-  PermissionMetadata as PermissionMeta,
-}
-export type { AgentsMeta }
-export type AgentMeta = AgentsMeta[string]
-
-export interface MCPMeta {
-  resources: MCPResourceMeta
-  tools: MCPToolMeta
-  prompts: MCPPromptMeta
-}
-
-export type RPCMetaRecord = Record<string, string>
-
-export interface ServiceMeta {
-  name: string
-  summary: string
-  description: string
-  package: string
-  path: string
-  version: string
-  interface: string
-  expandedProperties: Record<string, string>
-}
-
-export type ServicesMetaRecord = Record<string, ServiceMeta>
-
-export interface MiddlewareDefinitionMeta {
-  services: { optimized: boolean; services: string[] }
-  sourceFile: string
-  position: number
-  exportedName: string | null
-  factory?: boolean
-  name?: string
-  description?: string
-  package?: string
-}
-
-export interface MiddlewareInstanceMeta {
-  definitionId: string
-  sourceFile: string
-  position: number
-  isFactoryCall: boolean
-}
-
-export interface GroupMeta {
-  exportName: string | null
-  sourceFile: string
-  position: number
-  services: { optimized: boolean; services: string[] }
-  count: number
-  instanceIds: string[]
-  isFactory: boolean
-}
-
-export interface MiddlewareGroupsMeta {
-  definitions: Record<string, MiddlewareDefinitionMeta>
-  instances: Record<string, MiddlewareInstanceMeta>
-  httpGroups: Record<string, GroupMeta>
-  tagGroups: Record<string, GroupMeta>
-}
-
-export interface PermissionDefinitionMeta {
-  services: { optimized: boolean; services: string[] }
-  sourceFile: string
-  position: number
-  exportedName: string | null
-  factory?: boolean
-  name?: string
-  description?: string
-}
-
-export interface PermissionsGroupsMeta {
-  definitions: Record<string, PermissionDefinitionMeta>
-}
-
-export interface EmailTemplateLocaleMeta {
-  contentHash: string
-  htmlHash: string
-  subjectHash: string
-  textHash: string
-}
-
-export interface EmailTemplateMeta {
-  variables: string[]
-  hasHtml: boolean
-  hasSubject: boolean
-  hasText: boolean
-  locales: Record<string, EmailTemplateLocaleMeta>
-}
-
-export interface EmailsMeta {
-  src: string
-  themeHash: string
-  templates: Record<string, EmailTemplateMeta>
-}
-
-export interface EmailTemplateAssets {
-  theme: Record<string, unknown>
-  strings: Record<string, unknown>
-  layout: string
-  partials: Record<string, string>
-  html: string
-  subject: string
-  text: string
-  missing: string[]
-}
-
-/** Every `relativePath` below is relative to the `.pikku` root directory. */
-export interface MetaService {
-  /** Undefined for remote/non-local implementations. */
-  readonly basePath?: string
-  readFile(relativePath: string): Promise<string | null>
-  readDir(relativePath: string): Promise<string[]>
-  /** Relative to the project root, one level above `.pikku`. */
-  readProjectFile(relativePath: string): Promise<string | null>
-  /**
-   * Reads an *installed addon package's* own `.pikku`, not the app's, with
-   * `relativePath` rooted there (`../README.md` reaches the package root).
-   * Optional because only local/Node implementations resolve packages — remote
-   * ones omit it and callers guard with `?.`.
-   */
-  readPackageFile?(
-    packageName: string,
-    relativePath: string
-  ): Promise<string | null>
-  readPackageDir?(packageName: string, relativePath: string): Promise<string[]>
-
-  getHttpMeta(): Promise<HTTPWiringsMeta>
-  getChannelsMeta(): Promise<ChannelsMeta>
-  getSchedulerMeta(): Promise<ScheduledTasksMeta>
-  getQueueMeta(): Promise<QueueWorkersMeta>
-  getCliMeta(): Promise<CLIMeta>
-  getMcpMeta(): Promise<MCPMeta>
-  getGatewayMeta(): Promise<GatewaysMeta>
-  getRpcMeta(): Promise<RPCMetaRecord>
-  getWorkflowMeta(): Promise<WorkflowsMeta>
-  getPersonasMeta(): Promise<Record<string, ResolvedPersona>>
-  /**
-   * The roles declared with `defineSystemRole`, keyed by name.
-   *
-   * A persona declares roles; a function checks scopes. Anything showing what a
-   * persona can reach — the console's persona page, a run's catalogue — needs
-   * this to get from one to the other, and needs it to be the same expansion the
-   * seed granted from rather than a second one.
-   */
-  getSystemRolesMeta(): Promise<SystemRoleDefinitionsMeta>
-  getFeaturesMeta(): Promise<FeaturesMeta>
-  getTriggerMeta(): Promise<TriggerMeta>
-  getTriggerSourceMeta(): Promise<TriggerSourceMeta>
-  getFunctionsMeta(): Promise<FunctionsMeta>
-  getMiddlewareGroupsMeta(): Promise<MiddlewareGroupsMeta>
-  getPermissionsGroupsMeta(): Promise<PermissionsGroupsMeta>
-  getAgentsMeta(): Promise<AgentsMeta>
-  getSecretsMeta(): Promise<SecretDefinitionsMeta>
-  getCredentialsMeta(): Promise<CredentialDefinitionsMeta>
-  getVariablesMeta(): Promise<VariableDefinitionsMeta>
-  getEmailMeta(): Promise<EmailsMeta>
-  getEmailTemplateAssets(
-    templateName: string,
-    locale: string
-  ): Promise<EmailTemplateAssets>
-  getServicesMeta(): Promise<ServicesMetaRecord>
-
-  getSchema(schemaName: string): Promise<JSONSchema7 | null>
-  getSchemas(schemaNames: string[]): Promise<Record<string, JSONSchema7 | null>>
-
-  clearCache(): void
-}
-
-export class LocalMetaService implements MetaService {
-  public readonly basePath: string
-
-  private httpMetaCache: HTTPWiringsMeta | null = null
-  private channelsMetaCache: ChannelsMeta | null = null
-  private schedulerMetaCache: ScheduledTasksMeta | null = null
-  private queueMetaCache: QueueWorkersMeta | null = null
-  private cliMetaCache: CLIMeta | null = null
-  private mcpMetaCache: MCPMeta | null = null
-  private gatewayMetaCache: GatewaysMeta | null = null
-  private rpcMetaCache: RPCMetaRecord | null = null
-  private workflowMetaCache: WorkflowsMeta | null = null
-  private personasMetaCache: Record<string, ResolvedPersona> | null = null
-  private systemRolesMetaCache: SystemRoleDefinitionsMeta | null = null
-  private featuresMetaCache: FeaturesMeta | null = null
-  private triggerMetaCache: TriggerMeta | null = null
-  private triggerSourceMetaCache: TriggerSourceMeta | null = null
-  private functionsMetaCache: FunctionsMeta | null = null
-  private servicesMetaCache: ServicesMetaRecord | null = null
-  private secretsMetaCache: SecretDefinitionsMeta | null = null
-  private credentialsMetaCache: CredentialDefinitionsMeta | null = null
-  private variablesMetaCache: VariableDefinitionsMeta | null = null
-  private middlewareGroupsMetaCache: MiddlewareGroupsMeta | null = null
-  private permissionsGroupsMetaCache: PermissionsGroupsMeta | null = null
-  private agentsMetaCache: AgentsMeta | null = null
-  private schemaCache = new Map<string, JSONSchema7>()
-
-  constructor(basePath: string) {
-    this.basePath = basePath
-  }
-
-  async readFile(relativePath: string): Promise<string | null> {
-    try {
-      return await readFile(join(this.basePath, relativePath), 'utf-8')
-    } catch {
-      return null
-    }
-  }
-
-  async readDir(relativePath: string): Promise<string[]> {
-    try {
-      return await readdir(join(this.basePath, relativePath))
-    } catch {
-      return []
-    }
-  }
-
-  async readProjectFile(relativePath: string): Promise<string | null> {
-    try {
-      return await readFile(join(this.basePath, '..', relativePath), 'utf-8')
-    } catch {
-      return null
-    }
-  }
-
-  // knowledge: decisions/internals/addon-package-roots-resolve-by-walking-node-module-search-paths.md
-  private packageRootCache = new Map<string, string | null>()
-  private resolvePackageRoot(packageName: string): string | null {
-    const cached = this.packageRootCache.get(packageName)
-    if (cached !== undefined) return cached
-    let root: string | null = null
-    try {
-      const require = createRequire(join(this.basePath, '..', 'index.js'))
-      for (const dir of require.resolve.paths(packageName) ?? []) {
-        const candidate = join(dir, packageName)
-        if (existsSync(join(candidate, 'package.json'))) {
-          root = candidate
-          break
-        }
-      }
-    } catch {
-      root = null
-    }
-    this.packageRootCache.set(packageName, root)
-    return root
-  }
-
-  async readPackageFile(
-    packageName: string,
-    relativePath: string
-  ): Promise<string | null> {
-    const root = this.resolvePackageRoot(packageName)
-    if (!root) return null
-    try {
-      return await readFile(join(root, '.pikku', relativePath), 'utf-8')
-    } catch {
-      return null
-    }
-  }
-
-  async readPackageDir(
-    packageName: string,
-    relativePath: string
-  ): Promise<string[]> {
-    const root = this.resolvePackageRoot(packageName)
-    if (!root) return []
-    try {
-      return await readdir(join(root, '.pikku', relativePath))
-    } catch {
-      return []
-    }
-  }
-
-  clearCache(): void {
-    this.httpMetaCache = null
-    this.channelsMetaCache = null
-    this.schedulerMetaCache = null
-    this.queueMetaCache = null
-    this.cliMetaCache = null
-    this.mcpMetaCache = null
-    this.gatewayMetaCache = null
-    this.rpcMetaCache = null
-    this.workflowMetaCache = null
-    this.personasMetaCache = null
-    this.systemRolesMetaCache = null
-    this.featuresMetaCache = null
-    this.triggerMetaCache = null
-    this.triggerSourceMetaCache = null
-    this.functionsMetaCache = null
-    this.servicesMetaCache = null
-    this.secretsMetaCache = null
-    this.credentialsMetaCache = null
-    this.variablesMetaCache = null
-    this.middlewareGroupsMetaCache = null
-    this.permissionsGroupsMetaCache = null
-    this.agentsMetaCache = null
-    this.schemaCache.clear()
-  }
-
-  private async readMetaJson<T>(
-    dir: string,
-    baseName: string
-  ): Promise<string | null> {
-    const verbose = await this.readFile(`${dir}/${baseName}-verbose.gen.json`)
-    if (verbose) return verbose
-    const minimal = await this.readFile(`${dir}/${baseName}.gen.json`)
-    if (minimal) return minimal
-    return null
-  }
-
-  async getHttpMeta(): Promise<HTTPWiringsMeta> {
-    if (this.httpMetaCache) return this.httpMetaCache
-
-    const content = await this.readMetaJson('http', 'pikku-http-wirings-meta')
-    this.httpMetaCache = content
-      ? JSON.parse(content)
-      : {
-          get: {},
-          post: {},
-          put: {},
-          delete: {},
-          patch: {},
-          head: {},
-          options: {},
-        }
-    return this.httpMetaCache!
-  }
-
-  async getChannelsMeta(): Promise<ChannelsMeta> {
-    if (this.channelsMetaCache) return this.channelsMetaCache
-
-    const content = await this.readMetaJson('channel', 'pikku-channels-meta')
-    this.channelsMetaCache = content ? JSON.parse(content) : {}
-    return this.channelsMetaCache!
-  }
-
-  async getSchedulerMeta(): Promise<ScheduledTasksMeta> {
-    if (this.schedulerMetaCache) return this.schedulerMetaCache
-
-    const content = await this.readMetaJson(
-      'scheduler',
-      'pikku-schedulers-wirings-meta'
-    )
-    this.schedulerMetaCache = content ? JSON.parse(content) : {}
-    return this.schedulerMetaCache!
-  }
-
-  async getQueueMeta(): Promise<QueueWorkersMeta> {
-    if (this.queueMetaCache) return this.queueMetaCache
-
-    const content = await this.readMetaJson(
-      'queue',
-      'pikku-queue-workers-wirings-meta'
-    )
-    this.queueMetaCache = content ? JSON.parse(content) : {}
-    return this.queueMetaCache!
-  }
-
-  async getCliMeta(): Promise<CLIMeta> {
-    if (this.cliMetaCache) return this.cliMetaCache
-
-    const content = await this.readMetaJson('cli', 'pikku-cli-wirings-meta')
-    this.cliMetaCache = content
-      ? JSON.parse(content)
-      : { programs: {}, renderers: {} }
-    return this.cliMetaCache!
-  }
-
-  async getMcpMeta(): Promise<MCPMeta> {
-    if (this.mcpMetaCache) return this.mcpMetaCache
-
-    const content = await this.readMetaJson('mcp', 'pikku-mcp-wirings-meta')
-    if (content) {
-      const mcpData = JSON.parse(content)
-      this.mcpMetaCache = {
-        resources: mcpData.resourcesMeta || {},
-        tools: mcpData.toolsMeta || {},
-        prompts: mcpData.promptsMeta || {},
-      }
-    } else {
-      this.mcpMetaCache = { resources: {}, tools: {}, prompts: {} }
-    }
-    return this.mcpMetaCache!
-  }
-
-  async getGatewayMeta(): Promise<GatewaysMeta> {
-    if (this.gatewayMetaCache) return this.gatewayMetaCache
-
-    const content = await this.readMetaJson(
-      'gateway',
-      'pikku-gateway-wirings-meta'
-    )
-    this.gatewayMetaCache = content ? JSON.parse(content) : {}
-    return this.gatewayMetaCache!
-  }
-
-  async getRpcMeta(): Promise<RPCMetaRecord> {
-    if (this.rpcMetaCache) return this.rpcMetaCache
-
-    try {
-      const content = await this.readFile('rpc/pikku-rpc-wirings-meta.gen.json')
-      this.rpcMetaCache = content ? JSON.parse(content) : {}
-      return this.rpcMetaCache!
-    } catch (error) {
-      console.error('Error reading RPC wirings metadata:', error)
-      this.rpcMetaCache = {}
-      return this.rpcMetaCache
-    }
-  }
-
-  private async readWorkflowMetaDir(
-    dir: string,
-    into: WorkflowsMeta
-  ): Promise<void> {
-    const files = await this.readDir(dir)
-    const jsonFiles = files.filter((f) => f.endsWith('.gen.json'))
-    const verboseFiles = jsonFiles.filter((f) => f.includes('-verbose'))
-    const minimalFiles = jsonFiles.filter((f) => !f.includes('-verbose'))
-    const verboseNames = new Set(
-      verboseFiles.map((f) => f.replace('-verbose.gen.json', ''))
-    )
-    const filesToRead = [
-      ...verboseFiles,
-      ...minimalFiles.filter(
-        (f) => !verboseNames.has(f.replace('.gen.json', ''))
-      ),
-    ]
-
-    await Promise.all(
-      filesToRead.map(async (file) => {
-        const content = await this.readFile(`${dir}/${file}`)
-        if (content) {
-          const meta = JSON.parse(content)
-          into[meta.name] = meta
-        }
-      })
-    )
-  }
-
-  async getWorkflowMeta(): Promise<WorkflowsMeta> {
-    if (this.workflowMetaCache) return this.workflowMetaCache
-
-    try {
-      const result: WorkflowsMeta = {}
-      // knowledge: decisions/internals/scenario-meta-lives-apart-from-app-meta-but-merges-when-read-off-disk.md
-      await Promise.all([
-        this.readWorkflowMetaDir('workflow/meta', result),
-        this.readWorkflowMetaDir('scenarios/meta', result),
-      ])
-
-      this.workflowMetaCache = result
-      return this.workflowMetaCache
-    } catch (error) {
-      console.error('Error reading Workflow wirings metadata:', error)
-      this.workflowMetaCache = {}
-      return this.workflowMetaCache
-    }
-  }
-
-  async getPersonasMeta(): Promise<Record<string, ResolvedPersona>> {
-    if (this.personasMetaCache) return this.personasMetaCache
-
-    const content = await this.readFile('workflow/personas.gen.json')
-    this.personasMetaCache = content ? JSON.parse(content) : {}
-    return this.personasMetaCache!
-  }
-
-  async getSystemRolesMeta(): Promise<SystemRoleDefinitionsMeta> {
-    if (this.systemRolesMetaCache) return this.systemRolesMetaCache
-
-    // Beside the scopes it is composed from, which is where codegen writes it.
-    const content = await this.readFile('scopes/pikku-roles-meta.gen.json')
-    this.systemRolesMetaCache = content ? JSON.parse(content) : {}
-    return this.systemRolesMetaCache!
-  }
-
-  async getFeaturesMeta(): Promise<FeaturesMeta> {
-    if (this.featuresMetaCache) return this.featuresMetaCache
-
-    const content = await this.readFile('scenarios/features.gen.json')
-    this.featuresMetaCache = content ? JSON.parse(content) : {}
-    return this.featuresMetaCache!
-  }
-
-  async getTriggerMeta(): Promise<TriggerMeta> {
-    if (this.triggerMetaCache) return this.triggerMetaCache
-
-    const content = await this.readMetaJson(
-      'trigger',
-      'pikku-trigger-wirings-meta'
-    )
-    this.triggerMetaCache = content ? JSON.parse(content) : {}
-    return this.triggerMetaCache!
-  }
-
-  async getTriggerSourceMeta(): Promise<TriggerSourceMeta> {
-    if (this.triggerSourceMetaCache) return this.triggerSourceMetaCache
-
-    const content = await this.readMetaJson(
-      'trigger',
-      'pikku-trigger-sources-meta'
-    )
-    this.triggerSourceMetaCache = content ? JSON.parse(content) : {}
-    return this.triggerSourceMetaCache!
-  }
-
-  async getFunctionsMeta(): Promise<FunctionsMeta> {
-    if (this.functionsMetaCache) return this.functionsMetaCache
-
-    const [content, scenarioContent] = await Promise.all([
-      this.readMetaJson('function', 'pikku-functions-meta'),
-      this.readMetaJson('scenarios', 'pikku-scenario-functions-meta'),
-    ])
-    this.functionsMetaCache = {
-      ...(content ? JSON.parse(content) : {}),
-      ...(scenarioContent ? JSON.parse(scenarioContent) : {}),
-    }
-    return this.functionsMetaCache!
-  }
-
-  async getMiddlewareGroupsMeta(): Promise<MiddlewareGroupsMeta> {
-    if (this.middlewareGroupsMetaCache) return this.middlewareGroupsMetaCache
-
-    const content = await this.readMetaJson(
-      'middleware',
-      'pikku-middleware-groups-meta'
-    )
-    this.middlewareGroupsMetaCache = content
-      ? JSON.parse(content)
-      : { definitions: {}, instances: {}, httpGroups: {}, tagGroups: {} }
-    return this.middlewareGroupsMetaCache!
-  }
-
-  async getPermissionsGroupsMeta(): Promise<PermissionsGroupsMeta> {
-    if (this.permissionsGroupsMetaCache) return this.permissionsGroupsMetaCache
-
-    const content = await this.readMetaJson(
-      'permissions',
-      'pikku-permissions-groups-meta'
-    )
-    this.permissionsGroupsMetaCache = content
-      ? JSON.parse(content)
-      : { definitions: {} }
-    return this.permissionsGroupsMetaCache!
-  }
-
-  async getAgentsMeta(): Promise<AgentsMeta> {
-    if (this.agentsMetaCache) return this.agentsMetaCache
-
-    const content = await this.readMetaJson('agent', 'pikku-agent-wirings-meta')
-    if (content) {
-      const parsed = JSON.parse(content)
-      this.agentsMetaCache = parsed.agentsMeta || parsed
-    } else {
-      this.agentsMetaCache = {}
-    }
-    return this.agentsMetaCache!
-  }
-
-  async getSecretsMeta(): Promise<SecretDefinitionsMeta> {
-    if (this.secretsMetaCache) return this.secretsMetaCache
-
-    const content = await this.readFile('secrets/pikku-secrets-meta.gen.json')
-    this.secretsMetaCache = content ? JSON.parse(content) : {}
-    return this.secretsMetaCache!
-  }
-
-  async getCredentialsMeta(): Promise<CredentialDefinitionsMeta> {
-    if (this.credentialsMetaCache) return this.credentialsMetaCache
-
-    const content = await this.readFile(
-      'credentials/pikku-credentials-meta.gen.json'
-    )
-    this.credentialsMetaCache = content ? JSON.parse(content) : {}
-    return this.credentialsMetaCache!
-  }
-
-  async getVariablesMeta(): Promise<VariableDefinitionsMeta> {
-    if (this.variablesMetaCache) return this.variablesMetaCache
-
-    const content = await this.readFile(
-      'variables/pikku-variables-meta.gen.json'
-    )
-    this.variablesMetaCache = content ? JSON.parse(content) : {}
-    return this.variablesMetaCache!
-  }
-
-  async getEmailMeta(): Promise<EmailsMeta> {
-    // knowledge: decisions/internals/email-meta-is-read-uncached-because-codegen-rewrites-it-mid-session.md
-    const content = await this.readFile('email/pikku-emails-meta.gen.json')
-    return content
-      ? JSON.parse(content)
-      : {
-          src: '',
-          themeHash: '',
-          templates: {},
-        }
-  }
-
-  async getEmailTemplateAssets(
-    templateName: string,
-    locale: string
-  ): Promise<EmailTemplateAssets> {
-    const emailsMeta = await this.getEmailMeta()
-    if (!emailsMeta.src) {
-      throw new Error(
-        'No generated email metadata found. Run `pikku emails generate`.'
-      )
-    }
-
-    // knowledge: decisions/internals/generated-src-paths-in-pikku-meta-are-absolute.md
-    const baseDir = emailsMeta.src
-    const readEmailFile = async (rel: string): Promise<string | null> => {
-      try {
-        return await readFile(join(baseDir, rel), 'utf-8')
-      } catch {
-        return null
-      }
-    }
-    const [
-      themeRaw,
-      localeRaw,
-      layoutRaw,
-      footerRaw,
-      templateHtml,
-      templateSubject,
-      templateText,
-    ] = await Promise.all([
-      readEmailFile('theme.json'),
-      readEmailFile(`locales/${locale}.json`),
-      readEmailFile('partials/layout.html'),
-      readEmailFile('partials/footer.html'),
-      readEmailFile(`templates/${templateName}.html`),
-      readEmailFile(`templates/${templateName}.subject.txt`),
-      readEmailFile(`templates/${templateName}.text.txt`),
-    ])
-
-    const missing = [
-      ...(themeRaw ? [] : ['theme']),
-      ...(localeRaw ? [] : ['locale']),
-      ...(templateHtml ? [] : ['html']),
-      ...(templateSubject ? [] : ['subject']),
-      ...(templateText ? [] : ['text']),
-    ]
-
-    if (missing.length > 0) {
-      console.warn(
-        `[email-assets] pid=${process.pid} template=${templateName} locale=${locale} baseDir=${baseDir} missing=${missing.join(',')}`
-      )
-    }
-
-    return {
-      theme: themeRaw ? (JSON.parse(themeRaw) as Record<string, unknown>) : {},
-      strings: localeRaw
-        ? (JSON.parse(localeRaw) as Record<string, unknown>)
-        : {},
-      layout: layoutRaw ?? '',
-      partials: {
-        footer: footerRaw ?? '',
-      },
-      html: templateHtml ?? '',
-      subject: templateSubject ?? '',
-      text: templateText ?? '',
-      missing,
-    }
-  }
-
-  async getServicesMeta(): Promise<ServicesMetaRecord> {
-    if (this.servicesMetaCache) return this.servicesMetaCache
-
-    try {
-      const files = await this.readDir('services')
-      const jsonFiles = files.filter((f) => f.endsWith('.gen.json'))
-
-      const result: ServicesMetaRecord = {}
-      await Promise.all(
-        jsonFiles.map(async (file) => {
-          const content = await this.readFile(`services/${file}`)
-          if (content) {
-            const meta: ServiceMeta = JSON.parse(content)
-            result[meta.name] = meta
-          }
-        })
-      )
-
-      this.servicesMetaCache = result
-      return this.servicesMetaCache
-    } catch (error) {
-      console.error('Error reading Services metadata:', error)
-      this.servicesMetaCache = {}
-      return this.servicesMetaCache
-    }
-  }
-
-  async getSchema(schemaName: string): Promise<JSONSchema7 | null> {
-    if (this.schemaCache.has(schemaName)) {
-      return this.schemaCache.get(schemaName)!
-    }
-
-    if (!/^[a-zA-Z0-9_\-\.]+$/.test(schemaName)) {
-      return null
-    }
-
-    try {
-      const content = await this.readFile(
-        `schemas/schemas/${schemaName}.schema.json`
-      )
-      if (!content) return null
-      const schema = JSON.parse(content) as JSONSchema7
-      this.schemaCache.set(schemaName, schema)
-      return schema
-    } catch (error) {
-      console.error(`Error reading schema ${schemaName}:`, error)
-      return null
-    }
-  }
-
-  async getSchemas(
-    schemaNames: string[]
-  ): Promise<Record<string, JSONSchema7 | null>> {
-    const results: Record<string, JSONSchema7 | null> = {}
-    await Promise.all(
-      schemaNames.map(async (name) => {
-        results[name] = await this.getSchema(name)
-      })
-    )
-    return results
-  }
-}