@vibe-forge/core 0.1.0

package/src/controllers/config/index.ts

@@ -0,0 +1,207 @@
+import { existsSync } from 'node:fs'
+import { mkdir, readFile, writeFile } from 'node:fs/promises'
+import { dirname, extname, resolve } from 'node:path'
+import process from 'node:process'
+
+import { dump, load } from 'js-yaml'
+
+import type { Config } from '../../config'
+import { resetConfigCache } from '../../config'
+
+export type ConfigSource = 'project' | 'user'
+
+export interface UpdateConfigFileOptions {
+  workspaceFolder?: string
+  source: ConfigSource
+  section: string
+  value: unknown
+}
+
+const shouldMaskKey = (key: string) => /key|token|secret|password/i.test(key)
+
+const projectConfigPaths = [
+  './.ai.config.json',
+  './infra/.ai.config.json',
+  './.ai.config.yaml',
+  './.ai.config.yml',
+  './infra/.ai.config.yaml',
+  './infra/.ai.config.yml'
+]
+
+const userConfigPaths = [
+  './.ai.dev.config.json',
+  './infra/.ai.dev.config.json',
+  './.ai.dev.config.yaml',
+  './.ai.dev.config.yml',
+  './infra/.ai.dev.config.yaml',
+  './infra/.ai.dev.config.yml'
+]
+
+const resolveConfigPath = (workspaceFolder: string, source: ConfigSource) => {
+  const paths = source === 'project' ? projectConfigPaths : userConfigPaths
+  for (const path of paths) {
+    const resolved = resolve(workspaceFolder, path)
+    if (existsSync(resolved)) {
+      return resolved
+    }
+  }
+  return resolve(workspaceFolder, paths[0])
+}
+
+const parseConfigContent = (format: string, content: string) => {
+  if (format === '.yaml' || format === '.yml') {
+    return (load(content) ?? {}) as Record<string, unknown>
+  }
+  return JSON.parse(content) as Record<string, unknown>
+}
+
+const serializeConfigContent = (format: string, value: Record<string, unknown>) => {
+  if (format === '.yaml' || format === '.yml') {
+    return `${dump(value, { noRefs: true, lineWidth: 120 })}\n`
+  }
+  return `${JSON.stringify(value, null, 2)}\n`
+}
+
+const mergeMaskedValues = (incoming: unknown, existing: unknown): unknown => {
+  if (Array.isArray(incoming)) return incoming
+  if (incoming != null && typeof incoming === 'object') {
+    const incomingRecord = incoming as Record<string, unknown>
+    const existingRecord = (existing != null && typeof existing === 'object')
+      ? (existing as Record<string, unknown>)
+      : {}
+    return Object.entries(incomingRecord).reduce<Record<string, unknown>>((acc, [key, val]) => {
+      if (shouldMaskKey(key) && val === '******') {
+        acc[key] = existingRecord[key]
+      } else {
+        acc[key] = mergeMaskedValues(val, existingRecord[key])
+      }
+      return acc
+    }, {})
+  }
+  return incoming
+}
+
+const updateConfigSection = (config: Config, section: string, value: unknown): Config => {
+  const nextConfig: Config = { ...config }
+  const sectionValue = (value != null && typeof value === 'object')
+    ? (value as Record<string, unknown>)
+    : {}
+
+  const updateField = <T extends keyof Config>(key: T, nextValue: Config[T] | undefined) => {
+    if (nextValue === undefined) {
+      delete nextConfig[key]
+    } else {
+      nextConfig[key] = nextValue
+    }
+  }
+
+  switch (section) {
+    case 'general': {
+      updateField('baseDir', sectionValue.baseDir as Config['baseDir'])
+      updateField('defaultAdapter', sectionValue.defaultAdapter as Config['defaultAdapter'])
+      updateField('defaultModelService', sectionValue.defaultModelService as Config['defaultModelService'])
+      updateField('defaultModel', sectionValue.defaultModel as Config['defaultModel'])
+      updateField('recommendedModels', sectionValue.recommendedModels as Config['recommendedModels'])
+      updateField('interfaceLanguage', sectionValue.interfaceLanguage as Config['interfaceLanguage'])
+      updateField('modelLanguage', sectionValue.modelLanguage as Config['modelLanguage'])
+      updateField('announcements', sectionValue.announcements as Config['announcements'])
+      updateField(
+        'permissions',
+        mergeMaskedValues(sectionValue.permissions, config.permissions) as Config['permissions']
+      )
+      updateField(
+        'env',
+        mergeMaskedValues(sectionValue.env, config.env) as Config['env']
+      )
+      updateField(
+        'notifications',
+        mergeMaskedValues(sectionValue.notifications, config.notifications) as Config['notifications']
+      )
+      updateField(
+        'shortcuts',
+        mergeMaskedValues(sectionValue.shortcuts, config.shortcuts) as Config['shortcuts']
+      )
+      return nextConfig
+    }
+    case 'conversation': {
+      updateField('conversation', mergeMaskedValues(sectionValue, config.conversation) as Config['conversation'])
+      return nextConfig
+    }
+    case 'modelServices': {
+      updateField(
+        'modelServices',
+        mergeMaskedValues(sectionValue, config.modelServices) as Config['modelServices']
+      )
+      return nextConfig
+    }
+    case 'adapters': {
+      updateField('adapters', mergeMaskedValues(sectionValue, config.adapters) as Config['adapters'])
+      return nextConfig
+    }
+    case 'plugins': {
+      updateField('plugins', sectionValue.plugins as Config['plugins'])
+      updateField(
+        'enabledPlugins',
+        mergeMaskedValues(sectionValue.enabledPlugins, config.enabledPlugins) as Config['enabledPlugins']
+      )
+      updateField(
+        'extraKnownMarketplaces',
+        mergeMaskedValues(
+          sectionValue.extraKnownMarketplaces,
+          config.extraKnownMarketplaces
+        ) as Config['extraKnownMarketplaces']
+      )
+      return nextConfig
+    }
+    case 'mcp': {
+      updateField(
+        'mcpServers',
+        mergeMaskedValues(sectionValue.mcpServers, config.mcpServers) as Config['mcpServers']
+      )
+      updateField(
+        'defaultIncludeMcpServers',
+        sectionValue.defaultIncludeMcpServers as Config['defaultIncludeMcpServers']
+      )
+      updateField(
+        'defaultExcludeMcpServers',
+        sectionValue.defaultExcludeMcpServers as Config['defaultExcludeMcpServers']
+      )
+      updateField(
+        'noDefaultVibeForgeMcpServer',
+        sectionValue.noDefaultVibeForgeMcpServer as Config['noDefaultVibeForgeMcpServer']
+      )
+      return nextConfig
+    }
+    case 'shortcuts': {
+      updateField(
+        'shortcuts',
+        mergeMaskedValues(sectionValue, config.shortcuts) as Config['shortcuts']
+      )
+      return nextConfig
+    }
+    default:
+      return nextConfig
+  }
+}
+
+export const updateConfigFile = async (options: UpdateConfigFileOptions) => {
+  const workspaceFolder = options.workspaceFolder ?? process.cwd()
+  const configPath = resolveConfigPath(workspaceFolder, options.source)
+  const format = extname(configPath).toLowerCase()
+  const hasExisting = existsSync(configPath)
+  const existingContent = hasExisting ? await readFile(configPath, 'utf-8') : ''
+  const existingConfig = hasExisting ? parseConfigContent(format, existingContent) : {}
+  const updatedConfig = updateConfigSection(existingConfig as Config, options.section, options.value)
+  await mkdir(dirname(configPath), { recursive: true })
+  await writeFile(
+    configPath,
+    serializeConfigContent(format, updatedConfig as Record<string, unknown>),
+    'utf-8'
+  )
+  resetConfigCache()
+  return { configPath, updatedConfig }
+}
+
+export const configController = {
+  updateConfigFile
+}

package/src/controllers/system/index.ts

@@ -0,0 +1,102 @@
+import { spawn } from 'node:child_process'
+import path from 'node:path'
+import process from 'node:process'
+
+import type { NotificationMetadata } from 'node-notifier'
+import notifier from 'node-notifier'
+import z from 'zod'
+
+const notifyOptionsSchema = z.object({
+  title: z.string().optional(),
+  description: z.string(),
+  icon: z.string().optional().describe('自定义图标路径'),
+  sound: z
+    .union([z.boolean(), z.string()])
+    .optional()
+    .describe('是否播放音效或指定音效文件路径'),
+  volume: z.number().optional().describe('音量，0-1 或 0-100'),
+  timeout: z
+    .union([z.number(), z.literal(false)])
+    .optional()
+    .describe('通知超时时间'),
+  actions: z.array(z.string()).optional().describe('通知操作按钮'),
+  needConfirm: z.boolean().optional().describe('是否需要用户确认')
+})
+
+type NotifyOptions = z.infer<typeof notifyOptionsSchema>
+
+export const notify = async (options: NotifyOptions) => {
+  const {
+    title,
+    description,
+    icon,
+    sound = true,
+    volume,
+    timeout = 10 * 60 * 1000,
+    needConfirm
+  } = options
+
+  // 默认图标
+  const defaultIcon = path.resolve(__dirname, './assets/mcp.png')
+  // 默认音效
+  const defaultSound = path.resolve(__dirname, './assets/completed.mp3')
+
+  const resolvedSound = typeof sound === 'string'
+    ? sound
+    : (sound ? defaultSound : undefined)
+  const resolvedVolume = typeof volume === 'number'
+    ? (volume > 1 ? Math.min(volume, 100) / 100 : Math.max(volume, 0))
+    : undefined
+  const shouldPlaySound = resolvedSound != null && resolvedVolume !== 0
+  const shouldUseNotifierSound = !(resolvedVolume != null && resolvedSound != null && process.platform === 'darwin')
+  if (shouldPlaySound && !shouldUseNotifierSound && resolvedSound != null) {
+    try {
+      const args = ['-v', `${resolvedVolume ?? 1}`, resolvedSound]
+      const proc = spawn('afplay', args, { stdio: 'ignore', detached: true })
+      proc.unref()
+    } catch {
+    }
+  }
+
+  const [response, metadata] = await new Promise<
+    [string, NotificationMetadata | undefined]
+  >((ok, no) => {
+    notifier.notify(
+      {
+        icon: icon || defaultIcon,
+        title,
+        sound: shouldUseNotifierSound ? resolvedSound : undefined,
+        message: description,
+        wait: true,
+        reply: true,
+        timeout
+      },
+      (err, response, metadata) => {
+        if (err) {
+          no(err)
+          return
+        }
+        if (!needConfirm) {
+          return
+        }
+        ok([response, metadata])
+      }
+    )
+    if (!needConfirm) {
+      ok([
+        'default',
+        {
+          activationType: 'default',
+          activationAt: Date.now().toLocaleString(),
+          deliveredAt: Date.now().toLocaleString()
+        }
+      ])
+    }
+  })
+  return { response, metadata }
+}
+
+export const systemController = {
+  notify,
+  notifyOptionsSchema
+}

package/src/controllers/task/generate-adapter-query-options.ts

@@ -0,0 +1,86 @@
+import process from 'node:process'
+
+import type { AdapterQueryOptions } from '#~/adapter/type.js'
+import { DefinitionLoader } from '#~/utils/definition-loader.js'
+import type { Definition, Filter, Skill } from '#~/utils/definition-loader.js'
+
+export async function generateAdapterQueryOptions(
+  type: 'spec' | 'entity' | undefined,
+  name?: string,
+  cwd: string = process.cwd()
+): Promise<Partial<AdapterQueryOptions>> {
+  const loader = new DefinitionLoader(cwd)
+  const options: Partial<AdapterQueryOptions> = {}
+  const systemPromptParts: string[] = []
+
+  // 1. 获取数据
+  // 1.1 获取默认数据
+  const entities = type !== 'entity'
+    ? await loader.loadDefaultEntities()
+    : []
+  const skills = await loader.loadDefaultSkills()
+  const rules = await loader.loadDefaultRules()
+  const specs = await loader.loadDefaultSpecs()
+
+  // 1.2 获取指定数据
+  const targetSkills: Definition<Skill>[] = []
+  let targetBody = ''
+  let targetToolsFilter: Filter | undefined
+  let targetMcpServersFilter: Filter | undefined
+  if (type && name) {
+    const data = {
+      spec: await loader.loadSpec(name),
+      entity: await loader.loadEntity(name)
+    }[type]
+    if (!data) {
+      throw new Error(`Failed to load ${type} ${name}`)
+    }
+    const { attributes, body } = data
+    if (
+      attributes.rules
+    ) {
+      // always load spec or entity tagged rules
+      rules.push(
+        ...(
+          await loader.loadRules(attributes.rules)
+        ).map((rule) => ({
+          ...rule,
+          attributes: {
+            ...rule.attributes,
+            // 实体或流程中的规则为默认加载
+            always: true
+          }
+        }))
+      )
+    }
+    if (
+      attributes.skills
+    ) {
+      targetSkills.push(...await loader.loadSkills(attributes.skills))
+    }
+
+    targetBody = body
+    targetToolsFilter = attributes.tools
+    targetMcpServersFilter = attributes.mcpServers
+  }
+
+  // 2. 基于数据生成上下文
+  // 2.1 加载关联上下文
+  systemPromptParts.push(loader.generateRulesPrompt(rules))
+  systemPromptParts.push(loader.generateSkillsPrompt(targetSkills))
+  // 2.2 加载上下文路由
+  systemPromptParts.push(loader.generateEntitiesRoutePrompt(entities))
+  systemPromptParts.push(loader.generateSkillsRoutePrompt(skills))
+  systemPromptParts.push(loader.generateSpecRoutePrompt(specs))
+  // 2.3 加载目标上下文与配置
+  systemPromptParts.push(targetBody)
+  targetToolsFilter && (
+    options.tools = targetToolsFilter
+  )
+  targetMcpServersFilter && (
+    options.mcpServers = targetMcpServersFilter
+  )
+
+  options.systemPrompt = systemPromptParts.join('\n\n')
+  return options
+}

package/src/controllers/task/index.ts

@@ -0,0 +1,2 @@
+export { generateAdapterQueryOptions } from './generate-adapter-query-options'
+export { run } from './run'

package/src/controllers/task/prepare.ts

@@ -0,0 +1,60 @@
+import process from 'node:process'
+
+import type { AdapterCtx, AdapterQueryOptions } from '@vibe-forge/core'
+import { loadConfig } from '@vibe-forge/core'
+import { getCache, setCache } from '@vibe-forge/core/utils/cache'
+import { createLogger } from '@vibe-forge/core/utils/create-logger'
+import { uuid } from '@vibe-forge/core/utils/uuid'
+
+import type { RunTaskOptions } from './type'
+
+export const prepare = async (
+  options: RunTaskOptions,
+  adapterOptions: AdapterQueryOptions
+) => {
+  const cwd = options.cwd ?? process.env.__VF_PROJECT_WORKSPACE_FOLDER__ ?? process.cwd()
+
+  const {
+    sessionId = uuid()
+  } = adapterOptions
+  const {
+    ctxId = process.env.__VF_PROJECT_AI_CTX_ID__ ?? sessionId,
+    env: envFromOptions
+  } = options
+  const {
+    __IS_LOADER_CLI__: _0,
+    ...prevEnv
+  } = {
+    ...process.env,
+    ...envFromOptions
+  }
+  const env: Record<string, string | null | undefined> = {
+    ...prevEnv,
+    __VF_PROJECT_AI_CTX_ID__: ctxId,
+    __VF_PROJECT_AI_SESSION_ID__: sessionId,
+    __VF_PROJECT_AI_RUN_TYPE__: adapterOptions.runtime,
+    // 移除 NODE_OPTIONS 环境变量，防止干扰子进程的运行环境
+    NODE_OPTIONS: undefined
+  }
+  const logger = createLogger(cwd, ctxId, sessionId, env?.LOG_PREFIX ?? '')
+
+  const jsonVariables: Record<string, string | null | undefined> = {
+    ...env,
+    WORKSPACE_FOLDER: cwd,
+    __VF_PROJECT_WORKSPACE_FOLDER__: cwd
+  }
+  const [config, userConfig] = await loadConfig({ jsonVariables })
+  return [
+    {
+      ctxId,
+      cwd,
+      env,
+      cache: {
+        set: (key, value) => setCache(cwd, ctxId, sessionId, key, value),
+        get: (key) => getCache(cwd, ctxId, sessionId, key)
+      },
+      logger,
+      configs: [config, userConfig]
+    } satisfies AdapterCtx
+  ] as const
+}

package/src/controllers/task/run.ts

@@ -0,0 +1,98 @@
+import type { AdapterCtx, AdapterOutputEvent, AdapterQueryOptions, TaskDetail } from '@vibe-forge/core'
+import { loadAdapter } from '@vibe-forge/core'
+import { setCache } from '@vibe-forge/core/utils/cache'
+
+import { prepare } from './prepare'
+import type { RunTaskOptions } from './type'
+
+declare module '@vibe-forge/core' {
+  interface Cache {
+    base: Omit<AdapterCtx, 'logger' | 'cache'>
+    detail: TaskDetail
+  }
+}
+
+export const run = async (
+  options: RunTaskOptions,
+  adapterOptions: AdapterQueryOptions
+) => {
+  const [ctx] = await prepare(options, adapterOptions)
+  const {
+    configs: [config, userConfig]
+  } = ctx
+
+  const { logger, cache, ...base } = ctx
+
+  await cache.set('base', base)
+
+  const startTime = Date.now()
+  logger.info('[Framework] Process start', {
+    ...base,
+    adapterOptions,
+    startDateTime: new Date(startTime).toLocaleString()
+  })
+  const adapters = {
+    ...config?.adapters,
+    ...userConfig?.adapters
+  }
+  // dprint-ignore
+  const adapterType =
+    // 0. adapter from options
+    options.adapter ??
+    // 1. config default adapter
+    config?.defaultAdapter ??
+    // 2. user config default adapter
+    userConfig?.defaultAdapter ??
+    // 3. first adapter in config
+    (() => {
+      const adapterNames = Object.keys(adapters)
+      if (adapterNames.length === 0) {
+        throw new Error('No adapter found in config, please set adapters in config file')
+      }
+      return adapterNames[0]
+    })()
+
+  const detail: TaskDetail = {
+    ctxId: ctx.ctxId,
+    sessionId: adapterOptions.sessionId,
+    status: 'running',
+    startTime,
+    description: adapterOptions.description,
+    adapter: adapterType,
+    model: adapterOptions.model
+  }
+
+  const saveDetail = async (d: TaskDetail) => {
+    // Save to caches/ctxId/detail.json (ignoring sessionId)
+    await setCache(ctx.cwd, ctx.ctxId, undefined, 'detail', d)
+  }
+
+  await saveDetail(detail)
+
+  const originalOnEvent = adapterOptions.onEvent
+  const wrappedOnEvent = (event: AdapterOutputEvent) => {
+    if (event.type === 'exit') {
+      detail.status = event.data.exitCode === 0 ? 'completed' : 'failed'
+      detail.endTime = Date.now()
+      detail.exitCode = event.data.exitCode ?? undefined
+      void saveDetail(detail).catch(console.error)
+    }
+    originalOnEvent(event)
+  }
+
+  const adapter = await loadAdapter(adapterType)
+  const session = await adapter.query(
+    ctx,
+    {
+      ...adapterOptions,
+      onEvent: wrappedOnEvent
+    }
+  )
+
+  if (session.pid) {
+    detail.pid = session.pid
+    await saveDetail(detail)
+  }
+
+  return { session, ctx }
+}

package/src/controllers/task/schema.ts

@@ -0,0 +1,131 @@
+import z from 'zod'
+
+export const TaskOptions = z.object({
+  type: z
+    .union([
+      z.literal('entity'),
+      // 基础库 API 能力开发
+      z.literal('spec')
+    ])
+    .describe('任务模式'),
+  name: z.string().describe('垂类知识库基准目标'),
+  specParams: z.record(z.string()).describe('SPEC 执行时的参数').optional(),
+  runtime: z
+    .object({
+      type: z
+        .string()
+        .describe('选择特定的 AI CLI 类型'),
+      noDefaultSystemPrompt: z
+        .boolean()
+        .describe('是否禁用默认的系统提示')
+        .optional()
+    }),
+  description: z
+    .string()
+    .describe('本次任务的描述，介绍关于本次任务需要进行的工作')
+    .optional(),
+  sessionId: z
+    .string()
+    .describe(
+      '复用上次会话的历史消息作为本次任务的上下文。\n' +
+        '- 通常如果某个任务在执行的时候出现了非预期的错误，那么你可以通过传入相同的 sessionID 来继续这个会话\n' +
+        '- 如果有一个步骤需要间隔执行，比如说先执行任务 A 的 A-1，然后完成后执行 B 的 B-1，等 B-1 这个完成后回到 A-1 继续执行 A-2 时也可以使用'
+    )
+    .optional(),
+  frontendTimeout: z
+    .number()
+    .describe(
+      '前台等待时间的上限，单位秒，默认值为 8 分钟。' +
+        '在超过这个时间后该任务会被转化为一个后台任务，并直接返回当前的输出以及 sessionId，你可以通过 sessionId 来继续这个任务，或者查询任务的状态'
+    )
+    .default(8 * 60)
+    .optional(),
+  defaultModel: z.string().describe('默认的模型').optional()
+})
+
+export type TaskOptions = z.infer<typeof TaskOptions>
+
+export const MCPRunTasksOptions = z.object({
+  tasks: z
+    .array(TaskOptions)
+    .describe(
+      '子任务列表。传递多个子任务时会并发执行多个，可用于优化整体任务效率。'
+    ),
+
+  bashDefaultTimeoutMs: z.number().optional(),
+  bashMaxTimeoutMs: z.number().optional(),
+  maxMcpOutputTokens: z.number().optional(),
+  mcpTimeout: z.number().optional(),
+  mcpToolTimeout: z.number().optional()
+})
+
+export type MCPRunTasksOptions = z.infer<typeof MCPRunTasksOptions>
+
+export const Options = z
+  .object({
+    taskId: z
+      .string()
+      .describe(
+        '唯一 id，会用于关联多个任务相关信息。\n' +
+          '如果是第一次执行，则不需要传入，会在返回值中自动生成一个，在下次创建或复用的时候必须传入该值以供记录相关上下文。\n' +
+          '用户指定了 taskId，则以用户指定的 taskId 为准，在创建任务时则必须要指定对应的 taskId 参数。'
+      )
+      .optional()
+  })
+  .extend(MCPRunTasksOptions.shape)
+
+export type Options = z.infer<typeof Options>
+
+export const Entity = z.object({
+  prompt: z
+    .string()
+    .describe('实体的描述，简单介绍一下当前实体的作用。')
+    .optional(),
+  promptPath: z
+    .string()
+    .describe(
+      '实体的描述文件路径，文件内容为实体的描述。默认为当前目录下的 AGENTS.md 文件。'
+    )
+    .optional(),
+  rules: z
+    .array(
+      z.union([
+        z.string(),
+        z.discriminatedUnion('type', [
+          z.object({
+            type: z.literal('local').optional(),
+            path: z.string(),
+            desc: z.string().optional()
+          }),
+          z.object({
+            type: z.literal('remote'),
+            tags: z.array(z.string()).describe('关键 tag').optional(),
+            desc: z.string().describe('知识库的描述').optional()
+          })
+        ])
+      ])
+    )
+    .optional()
+    .describe('垂类 agent 的规则集合'),
+  skills: z
+    .object({
+      type: z.union([z.literal('include'), z.literal('exclude')]),
+      list: z.array(z.string()).describe('技能列表')
+    })
+    .optional(),
+  mcpServers: z
+    .object({
+      include: z.array(z.string()).describe('包含的服务名称列表'),
+      exclude: z.array(z.string()).describe('排除的服务名称列表')
+    })
+    .optional(),
+  tools: z
+    .object({
+      include: z.array(z.string()).describe('包含的工具名称列表'),
+      exclude: z.array(z.string()).describe('排除的工具名称列表')
+    })
+    .optional(),
+  defaultModel: z.string().optional()
+})
+
+export type Entity = z.infer<typeof Entity>

package/src/controllers/task/type.ts

@@ -0,0 +1,6 @@
+export interface RunTaskOptions {
+  ctxId?: string
+  adapter?: string
+  env?: Record<string, string | undefined | null>
+  cwd?: string
+}