@vibe-forge/core 0.1.0

package/src/env.ts

@@ -0,0 +1,43 @@
+import { env as processEnv } from 'node:process'
+
+export interface ServerEnv {
+  __VF_PROJECT_AI_SERVER_HOST__: string
+  __VF_PROJECT_AI_SERVER_PORT__: number
+  __VF_PROJECT_AI_SERVER_WS_PATH__: string
+  __VF_PROJECT_AI_SERVER_DATA_DIR__: string
+  __VF_PROJECT_AI_SERVER_LOG_DIR__: string
+  __VF_PROJECT_AI_SERVER_LOG_LEVEL__: 'debug' | 'info' | 'warn' | 'error'
+  __VF_PROJECT_AI_SERVER_ALLOW_CORS__: boolean
+  __VF_PROJECT_AI_ADAPTER_CLAUDE_CODE_CLI_PATH__?: string
+  __VF_PROJECT_AI_ADAPTER_CLAUDE_CODE_CLI_ARGS__?: string
+}
+
+export function loadEnv(): ServerEnv {
+  const {
+    __VF_PROJECT_AI_SERVER_HOST__ = 'localhost',
+    __VF_PROJECT_AI_SERVER_PORT__ = '8787',
+    __VF_PROJECT_AI_SERVER_WS_PATH__ = '/ws',
+    __VF_PROJECT_AI_SERVER_DATA_DIR__ = '.data',
+    __VF_PROJECT_AI_SERVER_LOG_DIR__ = '.logs',
+    __VF_PROJECT_AI_SERVER_LOG_LEVEL__ = 'info',
+    __VF_PROJECT_AI_SERVER_ALLOW_CORS__,
+
+    __VF_PROJECT_AI_ADAPTER_CLAUDE_CODE_CLI_PATH__,
+    __VF_PROJECT_AI_ADAPTER_CLAUDE_CODE_CLI_ARGS__
+  } = processEnv || {}
+  return {
+    __VF_PROJECT_AI_SERVER_HOST__,
+    __VF_PROJECT_AI_SERVER_PORT__: Number(__VF_PROJECT_AI_SERVER_PORT__),
+    __VF_PROJECT_AI_SERVER_WS_PATH__,
+    __VF_PROJECT_AI_SERVER_DATA_DIR__,
+    __VF_PROJECT_AI_SERVER_LOG_DIR__,
+    __VF_PROJECT_AI_SERVER_LOG_LEVEL__:
+      __VF_PROJECT_AI_SERVER_LOG_LEVEL__ as ServerEnv['__VF_PROJECT_AI_SERVER_LOG_LEVEL__'],
+    __VF_PROJECT_AI_SERVER_ALLOW_CORS__: __VF_PROJECT_AI_SERVER_ALLOW_CORS__ != null
+      ? __VF_PROJECT_AI_SERVER_ALLOW_CORS__ === 'true'
+      : true,
+
+    __VF_PROJECT_AI_ADAPTER_CLAUDE_CODE_CLI_PATH__,
+    __VF_PROJECT_AI_ADAPTER_CLAUDE_CODE_CLI_ARGS__
+  }
+}

package/src/hooks/index.ts

@@ -0,0 +1,37 @@
+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 './loader'
+export * from './type'

package/src/hooks/loader.ts

@@ -0,0 +1,75 @@
+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): Promise<Partial<Plugin>[]> => {
+  // 1. 处理数组形式配置 (直接实例化或函数调用)
+  if (Array.isArray(config)) {
+    return config.map((p) => (typeof p === 'function' ? p() : p))
+  }
+
+  // 2. 处理对象形式配置 (动态加载)
+  const entries = Object.entries(config)
+  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/type.ts

@@ -0,0 +1,173 @@
+/**
+ * https://docs.anthropic.com/en/docs/claude-code/hooks#hook-input
+ */
+export interface HookInputCore {
+  cwd: string
+  sessionId: string
+  hookEventName: keyof HookInputs
+  transcriptPath: string
+}
+
+/**
+ * https://docs.anthropic.com/en/docs/claude-code/settings#tools-available-to-claude
+ */
+export interface ToolInputs {
+  mcp__TmarAITools__notify: {
+    title: string
+    description: string
+    sound?: boolean
+  }
+  'mcp__TmarAITools__run-tasks': {
+    taskId: string
+    agents: number[]
+  }
+  Read: {
+    filePath: string
+  }
+  LS: {
+    path: string
+  }
+  Edit: {
+    filePath: string
+    newString: string
+    oldString: string
+  }
+  Write: {
+    filePath: string
+    content: string
+  }
+  Bash: {
+    command: string
+    description: string
+  }
+}
+
+export interface ToolOutputs {
+  mcp__TmarAITools__notify: {}
+  'mcp__TmarAITools__run-tasks': {}
+  Read: {
+    type: 'text' | (string & {})
+    file: {
+      filePath: string
+      content: string
+      numLines: number
+      startLine: number
+      totalLines: number
+    }
+  }
+  LS: string
+  Edit: {
+    filePath: string
+    newString: string
+    oldString: string
+    originalFile: string
+  }
+  Write: {
+    filePath: string
+    content: string
+  }
+  Bash: {
+    stdout: string
+    stderr: string
+    interrupted: boolean
+    isImage: boolean
+  }
+}
+
+// dprint-ignore
+export type ToolInput = keyof ToolInputs extends infer Keys
+  ? Keys extends infer Key extends keyof ToolInputs
+    ? {
+      toolName: Key
+      toolInput: ToolInputs[Key]
+    }
+    : never
+  : never
+
+// dprint-ignore
+export type ToolOutput = keyof ToolOutputs extends infer Keys
+  ? Keys extends infer Key extends keyof ToolOutputs
+    ? {
+      toolName: Key
+      toolInput: ToolInputs[Key]
+      toolResponse?: ToolOutputs[Key]
+    }
+    : never
+  : never
+
+export interface HookInputs {
+  /**
+   * https://docs.anthropic.com/en/docs/claude-code/hooks#pretooluse-input
+   */
+  PreToolUse: HookInputCore & ToolInput
+  /**
+   * https://docs.anthropic.com/en/docs/claude-code/hooks#posttooluse-input
+   */
+  PostToolUse: HookInputCore & ToolOutput
+  Notification: HookInputCore
+  UserPromptSubmit: HookInputCore & { prompt: string }
+  Stop: HookInputCore
+  SubagentStop: HookInputCore
+  PreCompact: HookInputCore
+  SessionStart: HookInputCore
+  SessionEnd: HookInputCore & {
+    reason: string
+  }
+}
+
+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
+}
+
+export type HookOutput = HookOutputs[keyof HookOutputs]

package/src/index.ts

@@ -0,0 +1,9 @@
+export * from './adapter'
+export * from './config'
+export * from './controllers/config'
+export * from './controllers/system'
+export * from './env'
+export * from './hooks'
+export * from './schema'
+export * from './types'
+export * from './ws'

package/src/schema.ts

@@ -0,0 +1,13 @@
+import z from 'zod'
+
+export const InteractionOptionSchema = z.object({
+  label: z.string(),
+  description: z.string().optional()
+})
+
+export const AskUserQuestionParamsSchema = z.object({
+  sessionId: z.string(),
+  question: z.string(),
+  options: z.array(InteractionOptionSchema).optional(),
+  multiselect: z.boolean().optional()
+})

package/src/types.ts

@@ -0,0 +1,66 @@
+import type { z } from 'zod'
+import type { AskUserQuestionParamsSchema, InteractionOptionSchema } from './schema.js'
+
+export interface Project {
+  id: string
+  name: string
+  path: string
+}
+
+export type SessionStatus = 'running' | 'completed' | 'failed' | 'terminated' | 'waiting_input'
+
+export interface Session {
+  id: string
+  parentSessionId?: string
+  title?: string
+  createdAt: number
+  messageCount?: number
+  lastMessage?: string
+  lastUserMessage?: string
+  isStarred?: boolean
+  isArchived?: boolean
+  tags?: string[]
+  status?: SessionStatus
+}
+
+export type ChatMessageContent =
+  | { type: 'text'; text: string }
+  | { type: 'tool_use'; id: string; name: string; input: any }
+  | { type: 'tool_result'; tool_use_id: string; content: any; is_error?: boolean }
+
+export interface ChatMessage {
+  id: string
+  role: 'user' | 'assistant' | 'system'
+  content: string | ChatMessageContent[]
+  model?: string
+  usage?: {
+    input_tokens: number
+    output_tokens: number
+    cache_read_input_tokens?: number
+    cache_creation_input_tokens?: number
+  }
+  toolCall?: {
+    id?: string
+    name: string
+    args: Record<string, unknown>
+    status?: 'pending' | 'success' | 'error'
+    output?: unknown
+  }
+  createdAt: number
+}
+
+export type InteractionOption = z.infer<typeof InteractionOptionSchema>
+export type AskUserQuestionParams = z.infer<typeof AskUserQuestionParamsSchema>
+
+export interface TaskDetail {
+  ctxId: string
+  sessionId: string
+  status: 'pending' | 'running' | 'completed' | 'failed' | 'stopped'
+  pid?: number
+  startTime: number
+  endTime?: number
+  description?: string
+  adapter: string
+  model?: string
+  exitCode?: number
+}

package/src/utils/cache.ts

@@ -0,0 +1,51 @@
+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)
+  await fs.access(cachePath)
+  return JSON.parse(await fs.readFile(cachePath, 'utf-8'))
+}

package/src/utils/create-logger.ts

@@ -0,0 +1,74 @@
+import { createWriteStream, existsSync, mkdirSync } from 'node:fs'
+import { dirname, resolve } from 'node:path'
+
+export interface Logger {
+  stream: NodeJS.WritableStream
+  info: (...args: unknown[]) => void
+  warn: (...args: unknown[]) => void
+  debug: (...args: unknown[]) => void
+  error: (...args: unknown[]) => void
+}
+
+export const createLogger = (
+  cwd: string,
+  taskId: string,
+  sessionId: string,
+  logPrefix = ''
+) => {
+  const date = new Date()
+  // 以 年-月-日-小时 作为一级目录名
+  const dateDir = `${date.getFullYear()}-${date.getMonth() + 1}-${date.getDate()}-${date.getHours()}`
+
+  const loggerFilePath = resolve(
+    cwd,
+    `.ai${logPrefix}/logs/${taskId}/${dateDir}/${sessionId ?? 'default'}.log.md`
+  )
+  // 默认日志文件不存在时，创建一个默认的日志文件
+  if (!existsSync(loggerFilePath)) {
+    mkdirSync(dirname(loggerFilePath), { recursive: true })
+  }
+  const loggerStream = createWriteStream(loggerFilePath, {
+    flags: 'a'
+  })
+  const createLog = (tag: string) => (...args: unknown[]) => {
+    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'),
+    warn: createLog('W'),
+    debug: createLog('D'),
+    error: createLog('E')
+  }
+}