@vibe-forge/core 0.7.5 → 0.8.3

package/src/hooks/runtime.ts

@@ -1,139 +0,0 @@
-import { Buffer } from 'node:buffer'
-import process from 'node:process'
-
-import { loadConfig, resetConfigCache } from '#~/config/load.js'
-import { resolveServerLogLevel } from '#~/env.js'
-import { createLogger } from '#~/utils/create-logger.js'
-import { transformCamelKey } from '#~/utils/string-transform.js'
-
-import type { HookInput, HookInputs, HookOutputCore, HookOutputs } from './type'
-import type { HookContext, Plugin } from './index'
-import { resolvePlugins } from './loader'
-
-export const callPluginHook = async <K extends keyof HookInputs>(
-  eventName: K,
-  context: HookContext,
-  input: HookInputs[K],
-  plugins: Partial<Plugin>[] = []
-): Promise<HookOutputs[K]> => {
-  const { logger } = context
-  const filteredPlugins = plugins.filter(
-    (
-      item
-    ): item is
-      & {
-        name?: string
-      }
-      & {
-        [P in K]: NonNullable<Plugin[P]>
-      } => !!item && !!item[eventName]
-  )
-
-  let index = 0
-
-  const next = async (): Promise<HookOutputs[K]> => {
-    if (index >= filteredPlugins.length) {
-      return { continue: true }
-    }
-
-    const currentPlugin = filteredPlugins[index]
-    const { name = '<anonymous>', [eventName]: hook } = currentPlugin
-    index++
-
-    const withNameLogger = {
-      ...logger,
-      info: logger.info.bind(logger, `[plugin.${name}]`),
-      warn: logger.warn.bind(logger, `[plugin.${name}]`),
-      debug: logger.debug.bind(logger, `[plugin.${name}]`),
-      error: logger.error.bind(logger, `[plugin.${name}]`)
-    }
-
-    try {
-      return await hook(
-        {
-          ...context,
-          logger: withNameLogger
-        },
-        input,
-        next
-      )
-    } catch (error) {
-      if (error instanceof Error && !error.name.includes('[plugin.')) {
-        error.name = `${error.name}[plugin.${name}]`
-      }
-      throw error
-    }
-  }
-
-  return next()
-}
-
-export const executeHookInput = async (
-  input: HookInput,
-  env: Record<string, string | null | undefined> = process.env
-) => {
-  const workspaceFolder = env.__VF_PROJECT_WORKSPACE_FOLDER__ ?? input.cwd ?? process.env.HOME ?? '/'
-  const ctxId = env.__VF_PROJECT_AI_CTX_ID__ ?? input.sessionId ?? 'default'
-  const logPrefix = env.__VF_PROJECT_AI_LOG_PREFIX__ ?? ''
-  const loggerBase = createLogger(
-    workspaceFolder,
-    ctxId,
-    input.sessionId,
-    logPrefix,
-    resolveServerLogLevel(env)
-  )
-
-  const logger: typeof loggerBase = {
-    ...loggerBase,
-    info: (...args) => loggerBase.info(`[${input.hookEventName}]`, ...args),
-    warn: (...args) => loggerBase.warn(`[${input.hookEventName}]`, ...args),
-    debug: (...args) => loggerBase.debug(`[${input.hookEventName}]`, ...args),
-    error: (...args) => loggerBase.error(`[${input.hookEventName}]`, ...args)
-  }
-
-  resetConfigCache()
-  const jsonVariables = {
-    ...env,
-    WORKSPACE_FOLDER: workspaceFolder,
-    __VF_PROJECT_WORKSPACE_FOLDER__: workspaceFolder
-  }
-  const [config, userConfig] = await loadConfig({ jsonVariables })
-  const plugins = [
-    ...await resolvePlugins(config?.plugins ?? [], config?.enabledPlugins ?? {}),
-    ...await resolvePlugins(userConfig?.plugins ?? [], userConfig?.enabledPlugins ?? {})
-  ]
-
-  return callPluginHook(
-    input.hookEventName,
-    { logger },
-    input as HookInputs[typeof input.hookEventName],
-    plugins
-  )
-}
-
-export const readHookInput = async () => {
-  const stdoutBuffer = await new Promise<Buffer>((resolve) => {
-    const chunks: Buffer[] = []
-    process.stdin.on('data', chunk => chunks.push(chunk))
-    process.stdin.once('end', () => resolve(Buffer.concat(chunks)))
-  })
-
-  return transformCamelKey<HookInput>(
-    JSON.parse(stdoutBuffer.toString() || '{}')
-  )
-}
-
-export const runHookCli = async () => {
-  try {
-    const input = await readHookInput()
-    const result = await executeHookInput(input)
-    console.log(JSON.stringify(result))
-  } catch (error) {
-    console.log(
-      JSON.stringify({
-        continue: false,
-        stopReason: `run hook error: ${String(error)}`
-      } satisfies HookOutputCore)
-    )
-  }
-}

package/src/hooks/type.ts

@@ -1,145 +0,0 @@
-import type { AdapterQueryOptions } from '../adapter'
-
-export type HookSource = 'native' | 'bridge'
-
-export interface HookToolCall {
-  toolCallId?: string
-  toolName: string
-  toolInput?: unknown
-}
-
-export interface HookToolResult extends HookToolCall {
-  toolResponse?: unknown
-  isError?: boolean
-}
-
-/**
- * https://docs.anthropic.com/en/docs/claude-code/hooks#hook-input
- */
-export interface HookInputCore {
-  cwd: string
-  sessionId: string
-  hookEventName: keyof HookInputs
-  adapter?: string
-  runtime?: AdapterQueryOptions['runtime']
-  hookSource?: HookSource
-  canBlock?: boolean
-}
-
-export interface HookInputs {
-  /**
-   * https://docs.anthropic.com/en/docs/claude-code/hooks#pretooluse-input
-   */
-  PreToolUse: HookInputCore & HookToolCall
-  /**
-   * https://docs.anthropic.com/en/docs/claude-code/hooks#posttooluse-input
-   */
-  PostToolUse: HookInputCore & HookToolResult
-  Notification: HookInputCore
-  UserPromptSubmit: HookInputCore & { prompt: string }
-  Stop: HookInputCore & {
-    lastAssistantMessage?: string
-  }
-  SubagentStop: HookInputCore
-  PreCompact: HookInputCore
-  SessionStart: HookInputCore & {
-    source?: 'startup' | 'resume'
-    model?: string
-  }
-  SessionEnd: HookInputCore & {
-    reason: string
-    exitCode?: number
-    stderr?: string
-    lastAssistantMessage?: string
-  }
-
-  StartTasks: HookInputCore & {
-    tasks: Array<{
-      description: string
-      type: 'default' | 'spec' | 'entity'
-      name?: string
-      adapter?: string
-      background?: boolean
-    }>
-  }
-  GenerateSystemPrompt: HookInputCore & {
-    type?: 'spec' | 'entity'
-    name?: string
-    data?: unknown
-  }
-  TaskStart: HookInputCore & {
-    adapter?: string
-    options: unknown
-    adapterOptions: unknown
-  }
-  TaskStop: HookInputCore & {
-    exitCode?: number
-    stderr?: string
-    adapter?: string
-
-    options: unknown
-    adapterOptions: unknown
-  }
-}
-
-export type HookInput = HookInputs[keyof HookInputs]
-
-/**
- * https://docs.anthropic.com/en/docs/claude-code/hooks#common-json-fields
- */
-export interface HookOutputCore {
-  /**
-   * Whether Claude should continue after hook execution
-   * @default true
-   */
-  continue?: boolean
-  /**
-   * Message shown when continue is false
-   */
-  stopReason?: string
-  /**
-   * Hide stdout from transcript mode
-   * @default false
-   */
-  suppressOutput?: boolean
-  /**
-   * Optional warning message shown to the user
-   */
-  systemMessage?: string
-}
-
-export interface HookOutputs {
-  /**
-   * https://docs.anthropic.com/en/docs/claude-code/hooks#pretooluse-decision-control
-   */
-  PreToolUse: HookOutputCore & {
-    hookSpecificOutput?: {
-      hookEventName: 'PreToolUse'
-      permissionDecision: 'allow' | 'deny' | 'ask'
-      permissionDecisionReason: string
-    }
-  }
-  /**
-   * https://docs.anthropic.com/en/docs/claude-code/hooks#posttooluse-decision-control
-   */
-  PostToolUse: HookOutputCore & {
-    hookSpecificOutput?: {
-      hookEventName: 'PostToolUse'
-      additionalContext: string
-    }
-  }
-  Notification: HookOutputCore
-  UserPromptSubmit: HookOutputCore
-  Stop: HookOutputCore
-  SessionStart: HookOutputCore
-  SessionEnd: HookOutputCore
-  SubagentStop: HookOutputCore
-  PreCompact: HookOutputCore
-
-  StartTasks: HookOutputCore
-  GenerateSystemPrompt: HookOutputCore
-  TaskStart: HookOutputCore
-  TaskStop: HookOutputCore
-}
-
-export type HookOutput = HookOutputs[keyof HookOutputs]

package/src/utils/cache.ts

@@ -1,58 +0,0 @@
-import * as fs from 'node:fs/promises'
-import { dirname, resolve } from 'node:path'
-
-import type { Cache } from '@vibe-forge/core'
-
-declare module '@vibe-forge/core' {
-  interface Cache {
-  }
-}
-
-export const getCachePath = (
-  cwd: string,
-  taskId: string,
-  sessionId: string | undefined,
-  key: keyof Cache
-) => {
-  const taskDir = resolve(cwd, '.ai/caches', taskId)
-  const cacheDir = sessionId ? resolve(taskDir, sessionId) : taskDir
-  return resolve(cacheDir, `${key}.json`)
-}
-
-export const setCache = async <K extends keyof Cache>(
-  cwd: string,
-  taskId: string,
-  sessionId: string | undefined,
-  key: K,
-  value: Cache[K]
-) => {
-  const cachePath = getCachePath(cwd, taskId, sessionId, key)
-  const cacheDir = dirname(cachePath)
-  try {
-    await fs.access(cacheDir)
-  } catch {
-    await fs.mkdir(cacheDir, { recursive: true })
-  }
-  await fs.writeFile(cachePath, JSON.stringify(value, null, 2), {
-    flag: 'w'
-  })
-  return { cachePath }
-}
-
-export const getCache = async <K extends keyof Cache>(
-  cwd: string,
-  taskId: string,
-  sessionId: string | undefined,
-  key: K
-): Promise<Cache[K] | undefined> => {
-  const cachePath = getCachePath(cwd, taskId, sessionId, key)
-  try {
-    await fs.access(cachePath)
-  } catch (error) {
-    if ((error as NodeJS.ErrnoException).code === 'ENOENT') {
-      return undefined
-    }
-    throw error
-  }
-  return JSON.parse(await fs.readFile(cachePath, 'utf-8'))
-}

package/src/utils/create-logger.ts

@@ -1,89 +0,0 @@
-import { createWriteStream, existsSync, mkdirSync } from 'node:fs'
-import { dirname, resolve } from 'node:path'
-
-import type { LogLevel } from '#~/env.js'
-
-export interface Logger {
-  stream: NodeJS.WritableStream
-  info: (...args: unknown[]) => void
-  warn: (...args: unknown[]) => void
-  debug: (...args: unknown[]) => void
-  error: (...args: unknown[]) => void
-}
-
-const LOG_LEVEL_PRIORITY: Record<LogLevel, number> = {
-  debug: 10,
-  info: 20,
-  warn: 30,
-  error: 40
-}
-
-export const createLogger = (
-  cwd: string,
-  taskId: string,
-  sessionId: string,
-  logPrefix = '',
-  level: LogLevel = 'info'
-) => {
-  const normalizedSessionId = sessionId ?? 'default'
-  const taskDir = resolve(
-    cwd,
-    `.ai${logPrefix}/logs/${taskId}`
-  )
-
-  const loggerFilePath = resolve(
-    taskDir,
-    `${normalizedSessionId}.log.md`
-  )
-  // 默认日志文件不存在时，创建一个默认的日志文件
-  if (!existsSync(loggerFilePath)) {
-    mkdirSync(dirname(loggerFilePath), { recursive: true })
-  }
-  const loggerStream = createWriteStream(loggerFilePath, {
-    flags: 'a'
-  })
-  const createLog = (tag: string, currentLevel: LogLevel) => (...args: unknown[]) => {
-    if (LOG_LEVEL_PRIORITY[currentLevel] < LOG_LEVEL_PRIORITY[level]) {
-      return
-    }
-    const msg = args
-      .map((arg) => {
-        if (typeof arg === 'string') {
-          return arg
-        }
-        if (arg instanceof Error) {
-          return (
-            '\n```text\n' +
-            `${arg.stack}\n` +
-            '```'
-          )
-        }
-        return (
-          '\n```json\n' +
-          `${JSON.stringify(arg, null, 2)}\n` +
-          '```'
-        )
-      })
-      .join(' ')
-    const now = new Date().toLocaleString()
-    if (loggerStream.writableEnded) {
-      const tempLoggerStream = createWriteStream(loggerFilePath, {
-        flags: 'a'
-      })
-      tempLoggerStream.write(
-        `# [${now}] __E__ UNEXPECTED LOGGER STREAM ENDED\n`
-      )
-      tempLoggerStream.write(`# [${now}] __${tag}__ ${msg}\n`)
-      tempLoggerStream.end()
-      return
-    }
-    loggerStream.write(`# [${now}] __${tag}__ ${msg}\n`)
-  }
-  return {
-    stream: loggerStream,
-    info: createLog('I', 'info'),
-    warn: createLog('W', 'warn'),
-    debug: createLog('D', 'debug'),
-    error: createLog('E', 'error')
-  }
-}