@vibe-forge/core 0.7.5 → 0.8.0

package/src/hooks/bridge.ts

@@ -1,368 +0,0 @@
-import type {
-  AdapterCtx,
-  AdapterEvent,
-  AdapterOutputEvent,
-  AdapterQueryOptions,
-  AdapterSession
-} from '#~/adapter/index.js'
-import type { ChatMessage, ChatMessageContent } from '#~/types.js'
-import type { HookInputs } from './type'
-
-import { callHook } from './call'
-
-const normalizeText = (value: unknown) => (
-  typeof value === 'string' && value.trim() !== '' ? value.trim() : undefined
-)
-
-const stringifyUnknown = (value: unknown) => {
-  try {
-    return JSON.stringify(value)
-  } catch {
-    return String(value)
-  }
-}
-
-const describeContentPart = (item: ChatMessageContent): string | undefined => {
-  switch (item.type) {
-    case 'text':
-      return normalizeText(item.text)
-    case 'image':
-      return normalizeText(item.name) != null ? `[Image: ${item.name}]` : '[Image attachment]'
-    case 'tool_use':
-      return `Tool request: ${item.name}`
-    case 'tool_result':
-      return typeof item.content === 'string' ? normalizeText(item.content) : stringifyUnknown(item.content)
-    default:
-      return undefined
-  }
-}
-
-const extractPromptText = (content: AdapterEvent['content']) => {
-  const parts = content
-    .map(describeContentPart)
-    .filter((value): value is string => value != null)
-
-  return parts.length > 0 ? parts.join('\n\n') : undefined
-}
-
-const extractAssistantText = (message: ChatMessage | undefined) => {
-  if (message == null) return undefined
-  if (typeof message.content === 'string') return normalizeText(message.content)
-
-  const parts = message.content
-    .filter((item): item is Extract<ChatMessageContent, { type: 'text' }> => item.type === 'text')
-    .map(item => normalizeText(item.text))
-    .filter((value): value is string => value != null)
-
-  return parts.length > 0 ? parts.join('') : undefined
-}
-
-const isToolUse = (
-  item: ChatMessageContent
-): item is Extract<ChatMessageContent, { type: 'tool_use' }> => item.type === 'tool_use'
-
-const isToolResult = (
-  item: ChatMessageContent
-): item is Extract<ChatMessageContent, { type: 'tool_result' }> => item.type === 'tool_result'
-
-interface HookOutputLike {
-  continue?: boolean
-  stopReason?: string
-}
-
-export interface AdapterHookBridge {
-  start: () => Promise<void>
-  prepareInitialPrompt: (prompt?: string) => Promise<string | undefined>
-  wrapSession: (session: AdapterSession) => AdapterSession
-  handleOutput: (event: AdapterOutputEvent) => void
-}
-
-export const createAdapterHookBridge = (params: {
-  ctx: Pick<AdapterCtx, 'cwd' | 'env' | 'logger'>
-  adapter: string
-  runtime: AdapterQueryOptions['runtime']
-  sessionId: string
-  type: AdapterQueryOptions['type']
-  model?: string
-  disabledEvents?: Array<keyof HookInputs>
-}): AdapterHookBridge => {
-  const {
-    ctx,
-    adapter,
-    runtime,
-    sessionId,
-    type,
-    model,
-    disabledEvents: rawDisabledEvents = []
-  } = params
-  const disabledEvents = new Set(rawDisabledEvents)
-
-  const pendingToolCalls = new Map<string, { toolName: string; toolInput?: unknown }>()
-  let emitQueue = Promise.resolve()
-  let killRequested = false
-  let lastAssistantMessage: string | undefined
-  let sessionEnded = false
-
-  const callBridgeHook = async (
-    eventName: Parameters<typeof callHook>[0],
-    input: Record<string, unknown>,
-    options: {
-      canBlock: boolean
-      enforce?: boolean
-      blockedMessage: string
-    }
-  ): Promise<HookOutputLike | undefined> => {
-    if (disabledEvents.has(eventName as keyof HookInputs)) {
-      return undefined
-    }
-
-    try {
-      const output = await callHook(
-        eventName as never,
-        {
-          cwd: ctx.cwd,
-          sessionId,
-          adapter,
-          runtime,
-          hookSource: 'bridge',
-          canBlock: options.canBlock,
-          ...input
-        } as never,
-        ctx.env
-      ) as HookOutputLike
-
-      if (options.enforce && output?.continue === false) {
-        throw new Error(output.stopReason ?? options.blockedMessage)
-      }
-
-      if (!options.canBlock && output?.continue === false) {
-        ctx.logger.warn(
-          `[HookBridge] Ignoring blocking output from observational ${String(eventName)} hook`,
-          output.stopReason
-        )
-      }
-
-      return output
-    } catch (error) {
-      ctx.logger.error(`[HookBridge] ${String(eventName)} failed`, error)
-      if (options.enforce) throw error
-      return undefined
-    }
-  }
-
-  const observeMessage = (message: ChatMessage) => {
-    const assistantText = extractAssistantText(message)
-    if (assistantText != null) lastAssistantMessage = assistantText
-    const preToolUseDisabled = disabledEvents.has('PreToolUse')
-    const postToolUseDisabled = disabledEvents.has('PostToolUse')
-    const needsPendingToolCalls = !postToolUseDisabled
-
-    if (Array.isArray(message.content)) {
-      for (const item of message.content) {
-        if (isToolUse(item)) {
-          if (needsPendingToolCalls) {
-            pendingToolCalls.set(item.id, {
-              toolName: item.name,
-              toolInput: item.input
-            })
-          }
-          if (!preToolUseDisabled) {
-            void callBridgeHook(
-              'PreToolUse',
-              {
-                toolCallId: item.id,
-                toolName: item.name,
-                toolInput: item.input
-              },
-              {
-                canBlock: false,
-                blockedMessage: 'PreToolUse hook attempted to block an observed tool call'
-              }
-            )
-          }
-        }
-
-        if (isToolResult(item)) {
-          const pending = pendingToolCalls.get(item.tool_use_id)
-          pendingToolCalls.delete(item.tool_use_id)
-          if (!postToolUseDisabled) {
-            void callBridgeHook(
-              'PostToolUse',
-              {
-                toolCallId: item.tool_use_id,
-                toolName: pending?.toolName ?? 'unknown',
-                toolInput: pending?.toolInput,
-                toolResponse: item.content,
-                isError: item.is_error ?? false
-              },
-              {
-                canBlock: false,
-                blockedMessage: 'PostToolUse hook attempted to block an observed tool result'
-              }
-            )
-          }
-        }
-      }
-    }
-
-    if (message.toolCall?.name != null) {
-      const toolCallId = message.toolCall.id ?? message.id
-      if (needsPendingToolCalls && !pendingToolCalls.has(toolCallId)) {
-        pendingToolCalls.set(toolCallId, {
-          toolName: message.toolCall.name,
-          toolInput: message.toolCall.args
-        })
-      }
-
-      if (!preToolUseDisabled) {
-        void callBridgeHook(
-          'PreToolUse',
-          {
-            toolCallId,
-            toolName: message.toolCall.name,
-            toolInput: message.toolCall.args
-          },
-          {
-            canBlock: false,
-            blockedMessage: 'PreToolUse hook attempted to block a legacy observed tool call'
-          }
-        )
-      }
-
-      if (!postToolUseDisabled && (message.toolCall.output != null || message.toolCall.status === 'error')) {
-        pendingToolCalls.delete(toolCallId)
-        void callBridgeHook(
-          'PostToolUse',
-          {
-            toolCallId,
-            toolName: message.toolCall.name,
-            toolInput: message.toolCall.args,
-            toolResponse: message.toolCall.output,
-            isError: message.toolCall.status === 'error'
-          },
-          {
-            canBlock: false,
-            blockedMessage: 'PostToolUse hook attempted to block a legacy observed tool result'
-          }
-        )
-      }
-    }
-  }
-
-  return {
-    start: async () => {
-      if (disabledEvents.has('SessionStart')) return
-      await callBridgeHook(
-        'SessionStart',
-        {
-          source: type === 'resume' ? 'resume' : 'startup',
-          model
-        },
-        {
-          canBlock: true,
-          enforce: true,
-          blockedMessage: 'SessionStart hook blocked session startup'
-        }
-      )
-    },
-    prepareInitialPrompt: async (prompt) => {
-      const normalizedPrompt = normalizeText(prompt)
-      if (normalizedPrompt == null) return normalizedPrompt
-      if (disabledEvents.has('UserPromptSubmit')) return normalizedPrompt
-
-      await callBridgeHook(
-        'UserPromptSubmit',
-        { prompt: normalizedPrompt },
-        {
-          canBlock: true,
-          enforce: true,
-          blockedMessage: 'UserPromptSubmit hook blocked the initial prompt'
-        }
-      )
-
-      return normalizedPrompt
-    },
-    wrapSession: (session) => ({
-      kill: () => {
-        killRequested = true
-        session.kill()
-      },
-      emit: (event) => {
-        emitQueue = emitQueue
-          .catch((error) => {
-            ctx.logger.error('[HookBridge] emit queue failed', error)
-          })
-          .then(async () => {
-            if (event.type === 'message') {
-              const prompt = extractPromptText(event.content)
-              if (prompt != null && !disabledEvents.has('UserPromptSubmit')) {
-                const output = await callBridgeHook(
-                  'UserPromptSubmit',
-                  { prompt },
-                  {
-                    canBlock: true,
-                    blockedMessage: 'UserPromptSubmit hook blocked the outgoing prompt'
-                  }
-                )
-
-                if (output?.continue === false) {
-                  ctx.logger.warn(
-                    '[HookBridge] Dropping outgoing message blocked by UserPromptSubmit hook',
-                    output.stopReason
-                  )
-                  return
-                }
-              }
-            }
-
-            session.emit(event)
-          })
-      },
-      get pid() {
-        return session.pid
-      }
-    }),
-    handleOutput: (event) => {
-      if (event.type === 'message' && event.data.role === 'assistant') {
-        observeMessage(event.data)
-        return
-      }
-
-      if (event.type === 'stop') {
-        if (disabledEvents.has('Stop')) return
-        void callBridgeHook(
-          'Stop',
-          {
-            lastAssistantMessage: extractAssistantText(event.data) ?? lastAssistantMessage
-          },
-          {
-            canBlock: false,
-            blockedMessage: 'Stop hook attempted to control an observed stop event'
-          }
-        )
-        return
-      }
-
-      if (event.type === 'exit' && !sessionEnded) {
-        sessionEnded = true
-        void callBridgeHook(
-          'SessionEnd',
-          {
-            reason: killRequested
-              ? 'terminated'
-              : (event.data.exitCode ?? 0) === 0
-                ? 'completed'
-                : 'failed',
-            exitCode: event.data.exitCode,
-            stderr: event.data.stderr,
-            lastAssistantMessage
-          },
-          {
-            canBlock: false,
-            blockedMessage: 'SessionEnd hook attempted to control an observed session end'
-          }
-        )
-      }
-    }
-  }
-}

package/src/hooks/call.ts

@@ -1,74 +0,0 @@
-import { Buffer } from 'node:buffer'
-import { spawn } from 'node:child_process'
-import path from 'node:path'
-import process from 'node:process'
-
-import type { HookInputs, HookOutputs } from './type'
-
-export type HookEventName = keyof HookInputs
-
-type HookInputPayload<K extends HookEventName> = Omit<HookInputs[K], 'hookEventName'>
-
-const pickHookEnv = (env: Record<string, unknown>): Record<string, string> => {
-  const result: Record<string, string> = {}
-  for (const [key, value] of Object.entries(env)) {
-    if (typeof value === 'string') {
-      result[key] = value
-    }
-  }
-  return result
-}
-
-const resolveHookCliJs = () => {
-  try {
-    const pkgJsonPath = require.resolve('@vibe-forge/cli/package.json')
-    return path.resolve(path.dirname(pkgJsonPath), 'call-hook.js')
-  } catch (error) {
-    throw new Error('Failed to resolve @vibe-forge/cli hook entry', { cause: error })
-  }
-}
-
-export const callHook = async <K extends HookEventName>(
-  hookEventName: K,
-  input: HookInputPayload<K>,
-  env: Record<string, unknown> = process.env
-): Promise<HookOutputs[K]> => {
-  const childEnv = pickHookEnv(env)
-  const child = spawn(process.execPath, [resolveHookCliJs()], {
-    cwd: typeof input.cwd === 'string' ? input.cwd : process.cwd(),
-    env: childEnv,
-    stdio: ['pipe', 'pipe', 'pipe']
-  })
-
-  const stdoutChunks: Buffer[] = []
-  const stderrChunks: Buffer[] = []
-
-  child.stdout.on('data', chunk => stdoutChunks.push(chunk))
-  child.stderr.on('data', chunk => stderrChunks.push(chunk))
-
-  const exitCode = await new Promise<number>((resolve, reject) => {
-    child.once('error', reject)
-    child.once('close', code => resolve(code ?? 0))
-    child.stdin.end(JSON.stringify({
-      ...input,
-      hookEventName
-    }))
-  })
-
-  const stdout = Buffer.concat(stdoutChunks).toString('utf-8').trim()
-  const stderr = Buffer.concat(stderrChunks).toString('utf-8').trim()
-
-  if (exitCode !== 0) {
-    throw new Error(`Failed to call hook: process exited with code ${exitCode}${stderr ? ` - ${stderr}` : ''}`)
-  }
-
-  if (stdout === '') {
-    return { continue: true } as HookOutputs[K]
-  }
-
-  try {
-    return JSON.parse(stdout) as HookOutputs[K]
-  } catch (error) {
-    throw new Error(`Failed to parse hook output: ${stdout}${stderr ? `\nstderr: ${stderr}` : ''}`, { cause: error })
-  }
-}

package/src/hooks/index.ts

@@ -1,41 +0,0 @@
-import type { Writable } from 'node:stream'
-
-import type { HookInputs, HookOutputs } from './type'
-
-export interface HookContext {
-  logger: {
-    stream: Writable
-    info: (...args: unknown[]) => void
-    warn: (...args: unknown[]) => void
-    debug: (...args: unknown[]) => void
-    error: (...args: unknown[]) => void
-  }
-}
-
-export type Plugin =
-  & {
-    name?: string
-  }
-  & {
-    [P in keyof HookInputs]: (
-      ctx: HookContext,
-      input: HookInputs[P],
-      next: () => Promise<HookOutputs[P]>
-    ) => Promise<HookOutputs[P]>
-  }
-
-export const definePlugin = (plugin: Partial<Plugin>) => plugin
-
-export interface PluginMap {}
-
-export type PluginConfig =
-  | (Partial<Plugin> | (() => Partial<Plugin>))[]
-  | Record<string, Record<string, unknown>>
-  | Partial<PluginMap>
-
-export * from './call'
-export * from './bridge'
-export * from './loader'
-export * from './native'
-export * from './runtime'
-export * from './type'

package/src/hooks/loader.ts

@@ -1,79 +0,0 @@
-import type { Plugin, PluginConfig } from './index'
-
-/**
- * 解析单个插件配置
- */
-const loadPlugin = async (
-  name: string,
-  config: Record<string, unknown>
-): Promise<Partial<Plugin> | null> => {
-  try {
-    // eslint-disable-next-line ts/no-require-imports
-    const module = require(`${name}/hooks`)
-
-    // 兼容 ESM default export 和 CJS module.exports
-    const factory: (
-      // 直接导出插件对象
-      | Partial<Plugin>
-      // 导出工厂函数，接受配置并返回插件对象
-      | ((config: Record<string, unknown>) => Partial<Plugin>)
-    ) = module.default ?? module
-
-    if (typeof factory === 'function') {
-      // TODO: 这里可以注入更多上下文，如全局配置、版本信息等
-      return factory(config)
-    } else if (typeof factory === 'object' && factory !== null) {
-      return factory
-    }
-
-    console.warn(`Plugin ${name} does not export a valid plugin factory or object.`)
-    return null
-  } catch (e) {
-    console.error(`Failed to load plugin ${name}:`, e)
-    return null
-  }
-}
-
-export const resolvePlugins = async (
-  config: PluginConfig,
-  enabledPlugins: Record<string, boolean> = {}
-): Promise<Partial<Plugin>[]> => {
-  // 1. 处理数组形式配置 (直接实例化或函数调用)
-  if (Array.isArray(config)) {
-    return config.map((p) => (typeof p === 'function' ? p() : p))
-  }
-
-  // 2. 处理对象形式配置 (动态加载)
-  const entries = Object.entries(config)
-    .filter(([pkgName]) => enabledPlugins[pkgName] !== false)
-  if (entries.length === 0) return []
-
-  // 并行加载所有插件
-  const modules = await Promise.allSettled(
-    entries.map(([pkgName, pkgConfig]) => {
-      // 如果不是以 @ 或 @vibe-forge/plugin- 开头，则默认加上 @vibe-forge/plugin- 前缀
-      const resolvedName = pkgName.startsWith('@') ? pkgName : `@vibe-forge/plugin-${pkgName}`
-      // dprint-ignore
-      return (
-        loadPlugin(resolvedName, pkgConfig as Record<string, unknown>) ??
-        loadPlugin(pkgName, pkgConfig as Record<string, unknown>)
-      )
-    })
-  )
-
-  // 收集成功加载的插件
-  const plugins: Partial<Plugin>[] = []
-
-  modules.forEach((result, index) => {
-    const pkgName = entries[index][0]
-    if (result.status === 'fulfilled') {
-      if (result.value) {
-        plugins.push(result.value)
-      }
-    } else {
-      console.error(`Error loading plugin ${pkgName}:`, result.reason)
-    }
-  })
-
-  return plugins
-}

package/src/hooks/native.ts

@@ -1,116 +0,0 @@
-import { mkdir, readFile, writeFile } from 'node:fs/promises'
-import { dirname, resolve } from 'node:path'
-import process from 'node:process'
-
-import type { AdapterCtx } from '../adapter'
-
-export interface NativeHookHandlerConfig {
-  type: 'command'
-  command: string
-  timeout?: number
-  statusMessage?: string
-}
-
-export interface NativeHookMatcherGroup {
-  matcher?: string
-  hooks?: NativeHookHandlerConfig[]
-}
-
-export interface NativeHooksConfigFile {
-  hooks?: Partial<Record<string, NativeHookMatcherGroup[]>> & Record<string, unknown>
-}
-
-const isPlainObject = (value: unknown): value is Record<string, unknown> => (
-  value != null && typeof value === 'object' && !Array.isArray(value)
-)
-
-export const hasManagedHookPlugins = (
-  ctx: Pick<AdapterCtx, 'assets'>
-) => (ctx.assets?.hookPlugins.length ?? 0) > 0
-
-export const resolveMockHome = (
-  cwd: string,
-  env: Pick<AdapterCtx, 'env'>['env']
-) => {
-  const explicitHome = env.HOME?.trim() || process.env.HOME?.trim()
-  return explicitHome ? resolve(explicitHome) : resolve(cwd, '.ai', '.mock')
-}
-
-export const resolveHookCliPackageDir = () => {
-  try {
-    const pkgJsonPath = require.resolve('@vibe-forge/cli/package.json')
-    return dirname(pkgJsonPath)
-  } catch (error) {
-    throw new Error('Failed to resolve @vibe-forge/cli for native hooks', { cause: error })
-  }
-}
-
-export const resolveHookCliScriptPath = (fileName: string) => (
-  resolve(resolveHookCliPackageDir(), fileName)
-)
-
-export const shellQuote = (value: string) => JSON.stringify(value)
-
-export const buildNodeScriptCommand = (params: {
-  nodePath: string
-  scriptPath: string
-}) => `${shellQuote(params.nodePath)} ${shellQuote(params.scriptPath)}`
-
-export const prepareManagedHookRuntime = (
-  ctx: Pick<AdapterCtx, 'cwd' | 'env'>
-) => {
-  const mockHome = resolveMockHome(ctx.cwd, ctx.env)
-  const cliPackageDir = resolveHookCliPackageDir()
-  const nodePath = process.execPath
-
-  ctx.env.__VF_PROJECT_CLI_PACKAGE_DIR__ = cliPackageDir
-  ctx.env.__VF_PROJECT_WORKSPACE_FOLDER__ = ctx.env.__VF_PROJECT_WORKSPACE_FOLDER__ ?? ctx.cwd
-  ctx.env.__VF_PROJECT_NODE_PATH__ = nodePath
-
-  return {
-    mockHome,
-    cliPackageDir,
-    nodePath
-  }
-}
-
-export const readJsonFileOrDefault = async <T>(filePath: string, fallback: T): Promise<T> => {
-  try {
-    return JSON.parse(await readFile(filePath, 'utf8')) as T
-  } catch (error) {
-    if ((error as NodeJS.ErrnoException)?.code === 'ENOENT') return fallback
-    throw error
-  }
-}
-
-export const writeJsonFile = async (filePath: string, value: unknown) => {
-  await mkdir(dirname(filePath), { recursive: true })
-  await writeFile(filePath, `${JSON.stringify(value, null, 2)}\n`, 'utf8')
-}
-
-export const mergeManagedHookGroups = (params: {
-  existing: unknown
-  eventNames: readonly string[]
-  enabled: boolean
-  isManagedGroup: (group: NativeHookMatcherGroup) => boolean
-  createGroup: (eventName: string) => NativeHookMatcherGroup
-  shouldManageEvent?: (eventName: string) => boolean
-}): NativeHooksConfigFile => {
-  const parsed = isPlainObject(params.existing) ? params.existing as NativeHooksConfigFile : {}
-  const hooks = isPlainObject(parsed.hooks) ? parsed.hooks : {}
-  const nextHooks: Record<string, unknown> = { ...hooks }
-
-  for (const eventName of params.eventNames) {
-    const groups = Array.isArray(hooks[eventName])
-      ? (hooks[eventName] as NativeHookMatcherGroup[]).filter(group => !params.isManagedGroup(group))
-      : []
-    nextHooks[eventName] = params.enabled && (params.shouldManageEvent?.(eventName) ?? true)
-      ? [...groups, params.createGroup(eventName)]
-      : groups
-  }
-
-  return {
-    ...parsed,
-    hooks: nextHooks
-  }
-}