@vibe-forge/core 0.7.5 → 0.8.3

package/src/controllers/benchmark/workspace.ts

@@ -1,179 +0,0 @@
-import { mkdir, readFile, rm, writeFile } from 'node:fs/promises'
-import { resolve } from 'node:path'
-import process from 'node:process'
-
-import { execCommand, execShellCommand, linkPreparedNodeModules, pathExists } from './utils'
-
-interface CategoryWorkspaceInput {
-  workspaceFolder?: string
-  category: string
-  baseCommit: string
-  setupCommand: string
-  timeoutSec: number
-}
-
-interface CaseWorkspaceInput {
-  workspaceFolder?: string
-  category: string
-  title: string
-  runId: string
-  baseCommit: string
-  setupCommand: string
-  timeoutSec: number
-}
-
-export interface CategoryWorkspaceState {
-  workspacePath: string
-  gitRoot: string
-}
-
-export interface CaseWorkspaceState extends CategoryWorkspaceState {
-  caseWorkspacePath: string
-}
-
-const categoryWorkspaceInflight = new Map<string, Promise<CategoryWorkspaceState>>()
-
-const resolveWorktreeRoot = (workspaceFolder = process.cwd()) =>
-  resolve(workspaceFolder, '.ai/worktress/benchmark')
-
-const findGitRoot = async (workspaceFolder: string) => {
-  const result = await execCommand({
-    command: 'git',
-    args: ['rev-parse', '--show-toplevel'],
-    cwd: workspaceFolder
-  })
-  if (result.exitCode !== 0) {
-    throw new Error(result.stderr || 'Failed to resolve git root')
-  }
-  return result.stdout.trim()
-}
-
-const detachWorktree = async (gitRoot: string, worktreePath: string) => {
-  const result = await execCommand({
-    command: 'git',
-    args: ['worktree', 'remove', '--force', worktreePath],
-    cwd: gitRoot
-  })
-  const output = `${result.stdout}\n${result.stderr}`
-  if (result.exitCode !== 0 && !output.includes('is not a working tree')) {
-    throw new Error(output.trim() || `Failed to remove worktree: ${worktreePath}`)
-  }
-}
-
-export const ensureCategoryWorkspace = async (input: CategoryWorkspaceInput): Promise<CategoryWorkspaceState> => {
-  const workspaceFolder = input.workspaceFolder ?? process.cwd()
-  const lockKey = `${workspaceFolder}:${input.category}`
-  const inflight = categoryWorkspaceInflight.get(lockKey)
-  if (inflight != null) {
-    return inflight
-  }
-
-  const promise = (async () => {
-    const gitRoot = await findGitRoot(workspaceFolder)
-    const worktreeRoot = resolveWorktreeRoot(workspaceFolder)
-    const workspacePath = resolve(worktreeRoot, input.category)
-    const statePath = resolve(workspacePath, '.benchmark-state.json')
-
-    await mkdir(worktreeRoot, { recursive: true })
-
-    const currentState = await pathExists(statePath)
-      ? JSON.parse(await readFile(statePath, 'utf-8')) as {
-          baseCommit?: string
-          setupCommand?: string
-        }
-      : null
-
-    const needsRecreate = !await pathExists(workspacePath) ||
-      currentState?.baseCommit !== input.baseCommit ||
-      currentState?.setupCommand !== input.setupCommand
-
-    if (needsRecreate) {
-      if (await pathExists(workspacePath)) {
-        await detachWorktree(gitRoot, workspacePath)
-        await rm(workspacePath, { force: true, recursive: true })
-      }
-      const addResult = await execCommand({
-        command: 'git',
-        args: ['worktree', 'add', '--force', '--detach', workspacePath, input.baseCommit],
-        cwd: gitRoot
-      })
-      if (addResult.exitCode !== 0) {
-        throw new Error(addResult.stderr || `Failed to create worktree for ${input.category}`)
-      }
-      if (input.setupCommand.trim() !== '') {
-        const setupResult = await execShellCommand({
-          command: input.setupCommand,
-          cwd: workspacePath,
-          timeoutMs: input.timeoutSec * 1000
-        })
-        if (setupResult.exitCode !== 0) {
-          throw new Error(setupResult.stderr || setupResult.stdout || 'Failed to prepare category workspace')
-        }
-      }
-      await writeFile(statePath, `${JSON.stringify({
-        baseCommit: input.baseCommit,
-        setupCommand: input.setupCommand
-      }, null, 2)}\n`, 'utf-8')
-    }
-
-    return {
-      workspacePath,
-      gitRoot
-    }
-  })()
-
-  categoryWorkspaceInflight.set(lockKey, promise)
-
-  try {
-    return await promise
-  } finally {
-    categoryWorkspaceInflight.delete(lockKey)
-  }
-}
-
-export const createCaseWorkspace = async (input: CaseWorkspaceInput): Promise<CaseWorkspaceState> => {
-  const categoryWorkspace = await ensureCategoryWorkspace(input)
-  const worktreeRoot = resolveWorktreeRoot(input.workspaceFolder ?? process.cwd())
-  const caseRoot = resolve(worktreeRoot, '.cases', input.category)
-  const caseWorkspacePath = resolve(caseRoot, `${input.title}-${input.runId}`)
-
-  await mkdir(caseRoot, { recursive: true })
-  if (await pathExists(caseWorkspacePath)) {
-    await detachWorktree(categoryWorkspace.gitRoot, caseWorkspacePath)
-    await rm(caseWorkspacePath, { force: true, recursive: true })
-  }
-
-  const addResult = await execCommand({
-    command: 'git',
-    args: ['worktree', 'add', '--force', '--detach', caseWorkspacePath, input.baseCommit],
-    cwd: categoryWorkspace.gitRoot
-  })
-  if (addResult.exitCode !== 0) {
-    throw new Error(addResult.stderr || `Failed to create case workspace for ${input.category}/${input.title}`)
-  }
-
-  await linkPreparedNodeModules(categoryWorkspace.workspacePath, caseWorkspacePath)
-
-  if (input.setupCommand.trim() !== '') {
-    const setupResult = await execShellCommand({
-      command: input.setupCommand,
-      cwd: caseWorkspacePath,
-      timeoutMs: input.timeoutSec * 1000
-    })
-    if (setupResult.exitCode !== 0) {
-      throw new Error(setupResult.stderr || setupResult.stdout || 'Failed to prepare case workspace')
-    }
-  }
-
-  return {
-    ...categoryWorkspace,
-    caseWorkspacePath
-  }
-}
-
-export const disposeCaseWorkspace = async (state: CaseWorkspaceState) => {
-  await detachWorktree(state.gitRoot, state.caseWorkspacePath)
-  if (await pathExists(state.caseWorkspacePath)) {
-    await rm(state.caseWorkspacePath, { force: true, recursive: true })
-  }
-}

package/src/controllers/config/index.ts

@@ -1,214 +0,0 @@
-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 'channels': {
-      updateField(
-        'channels',
-        mergeMaskedValues(sectionValue, config.channels) as Config['channels']
-      )
-      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

@@ -1,102 +0,0 @@
-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

@@ -1,25 +0,0 @@
-import process from 'node:process'
-
-import type { AdapterQueryOptions } from '#~/adapter/type.js'
-import { resolvePromptAssetSelection, resolveWorkspaceAssetBundle } from '#~/utils/workspace-assets.js'
-
-export async function generateAdapterQueryOptions(
-  type: 'spec' | 'entity' | undefined,
-  name?: string,
-  cwd: string = process.cwd(),
-  input?: {
-    skills?: AdapterQueryOptions['skills']
-  }
-) {
-  const bundle = await resolveWorkspaceAssetBundle({ cwd })
-  const [data, resolvedOptions] = await resolvePromptAssetSelection({
-    bundle,
-    type,
-    name,
-    input
-  })
-  return [
-    data,
-    resolvedOptions as Partial<AdapterQueryOptions>
-  ] as const
-}

package/src/controllers/task/index.ts

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

package/src/controllers/task/prepare.ts

@@ -1,74 +0,0 @@
-import process from 'node:process'
-
-import { loadConfig } from '@vibe-forge/core'
-import type { AdapterCtx, AdapterQueryOptions } from '@vibe-forge/core/adapter'
-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 { resolveWorkspaceAssetBundle } from '@vibe-forge/core/utils/workspace-assets'
-
-import { resolveServerLogLevel } from '#~/env.js'
-
-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 ?? '',
-    resolveServerLogLevel(env)
-  )
-
-  const jsonVariables: Record<string, string | null | undefined> = {
-    ...env,
-    WORKSPACE_FOLDER: cwd,
-    __VF_PROJECT_WORKSPACE_FOLDER__: cwd
-  }
-  const [config, userConfig] = await loadConfig({ jsonVariables })
-  const assets = await resolveWorkspaceAssetBundle({
-    cwd,
-    configs: [config, userConfig]
-  })
-  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],
-      assets
-    } satisfies AdapterCtx
-  ] as const
-}