Cordis 与一切皆插件

import type { Context } from '@deepseek-ai/cordis'

export const name = 'hello'

export function apply(ctx: Context) {
  console.log('hello from my first plugin')
}

# cordis.yml：一个配置项列表，loader 会挂载其中的每一项
- name: './hello.ts'

$ node --import tsx node_modules/@deepseek-ai/cordis/bin.js
hello from my first plugin

import type { Context } from '@deepseek-ai/cordis'

export const name = 'lifecycle-demo'

function heartbeat(ctx: Context) {
  console.log('heartbeat plugin loading')
  ctx.effect(() => {
    const timer = setInterval(() => console.log('tick'), 200)
    return () => {
      // 返回的 disposer 会在插件卸载时自动执行
      clearInterval(timer)
      console.log('heartbeat cleaned up')
    }
  })
}

export function apply(ctx: Context) {
  const fiber = ctx.plugin(heartbeat) // 从代码里挂载一个子插件，得到它的 fiber（运行时句柄）
  ctx.effect(() => {
    const timer = setTimeout(async () => {
      await fiber.dispose() // 卸载子插件：它的所有 effect 都会被撤销
      console.log('disposed')
      process.exit(0)
    }, 700)
    return () => clearTimeout(timer)
  })
}

heartbeat plugin loading
tick
tick
tick
heartbeat cleaned up
disposed

// greeter.ts：提供一个服务
import { Service, type Context } from '@deepseek-ai/cordis'

declare module '@deepseek-ai/cordis' {
  interface Context {
    greeter: GreeterService // 编译期：通过声明合并，让 ctx.greeter 有类型
  }
}

export class GreeterService extends Service {
  constructor(ctx: Context) {
    super(ctx, 'greeter') // 运行期：以 greeter 这个名字注册
  }

  greet(who: string) {
    return `Hello, ${who}!`
  }
}

export const name = 'greeter'

export function apply(ctx: Context) {
  ctx.plugin(GreeterService)
}

// consumer.ts：消费这个服务（no-check：它依赖上面的 greeter.ts，两者已在本地项目中一起做过类型检查并运行）
import type { Context } from '@deepseek-ai/cordis'
import type {} from './greeter.ts' // 只为了引入类型声明，运行时不会导入任何东西

export const name = 'consumer'
export const inject = ['greeter'] // greeter 就绪之前，这个插件会一直处于 PENDING

export function apply(ctx: Context) {
  console.log(ctx.greeter.greet('world'))
}

# 故意把 consumer 写在 greeter 前面
- name: './consumer.ts'
- name: './greeter.ts'

Hello, world!

import type { Context } from '@deepseek-ai/cordis'

declare module '@deepseek-ai/cordis' {
  interface Events {
    'demo/transform'(input: string, next: () => Promise<string>): Promise<string>
  }
}

export const name = 'waterfall-demo'

export function apply(ctx: Context) {
  // 监听器 1：包装下游的结果
  ctx.on('demo/transform', async (input, next) => {
    const downstream = await next()
    return downstream.toUpperCase()
  })

  // 监听器 2：自己做决定时直接短路
  ctx.on('demo/transform', async (input, next) => {
    if (input.includes('blocked')) return '** blocked **'
    return next()
  })

  void (async () => {
    console.log(await ctx.waterfall('demo/transform', 'hello', async () => 'hello'))
    console.log(await ctx.waterfall('demo/transform', 'blocked words', async () => 'blocked words'))
  })()
}

HELLO
** BLOCKED **

import type { Context } from '@deepseek-ai/cordis'
import Schema from '@deepseek-ai/schemastery'

export const name = 'config-demo'

export interface Config {
  greeting: string
  targets: string[]
}

// 同名导出：既是 TypeScript 接口，也是运行时用来校验的 schema
export const Config: Schema<Config> = Schema.object({
  greeting: Schema.string().default('Hello'),
  targets: Schema.array(String).default(['world']),
})

export function apply(ctx: Context, config: Config) {
  for (const target of config.targets) {
    console.log(`${config.greeting}, ${target}!`)
  }
}

- name: './config-demo.ts'
  config:
    targets: ['alpha', 'beta']

Hello, alpha!
Hello, beta!

- id: greeter          # 稳定的标识：loader 据此判断是“修改”还是“删除后再添加”
  name: './greeter.ts'
- id: consumer
  name: './consumer.ts'
  disabled: true       # 保留这个配置项，但不挂载它