@vibe-forge/core 0.2.0 → 0.4.0

package/src/controllers/benchmark/workspace.ts

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

@@ -134,6 +134,13 @@ const updateConfigSection = (config: Config, section: string, value: unknown): C
       )
       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

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

@@ -8,7 +8,7 @@ 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[] = []
@@ -82,5 +82,15 @@ export async function generateAdapterQueryOptions(
   )
 
   options.systemPrompt = systemPromptParts.join('\n\n')
-  return options
+  return [
+    {
+      rules,
+      targetSkills,
+      entities,
+      skills,
+      specs,
+      targetBody
+    },
+    options
+  ] as const
 }

package/src/controllers/task/run.ts

@@ -1,10 +1,82 @@
-import type { AdapterCtx, AdapterOutputEvent, AdapterQueryOptions, TaskDetail } from '@vibe-forge/core'
+import type {
+  AdapterCtx,
+  AdapterOutputEvent,
+  AdapterQueryOptions,
+  ModelServiceConfig,
+  TaskDetail
+} from '@vibe-forge/core'
 import { loadAdapter } from '@vibe-forge/core'
-import { setCache } from '@vibe-forge/core/utils/cache'
+import { callHook } from '@vibe-forge/core/utils/api'
 
 import { prepare } from './prepare'
 import type { RunTaskOptions } from './type'
 
+const normalizeNonEmptyString = (value: unknown) => (
+  typeof value === 'string' && value.trim() !== '' ? value.trim() : undefined
+)
+
+const pickFirstNonEmptyString = (values: unknown[]) =>
+  values
+    .map(normalizeNonEmptyString)
+    .find((value): value is string => value != null)
+
+const resolveQueryModel = (params: {
+  config: AdapterCtx['configs'][0]
+  userConfig: AdapterCtx['configs'][1]
+  inputModel?: string
+}) => {
+  const inputModel = normalizeNonEmptyString(params.inputModel)
+  if (inputModel?.includes(',')) return inputModel
+
+  const mergedModelServices = {
+    ...(params.config?.modelServices ?? {}),
+    ...(params.userConfig?.modelServices ?? {})
+  }
+  const mergedDefaultModel = pickFirstNonEmptyString([params.userConfig?.defaultModel, params.config?.defaultModel])
+  const mergedDefaultModelService = pickFirstNonEmptyString([
+    params.userConfig?.defaultModelService,
+    params.config?.defaultModelService
+  ])
+
+  const serviceEntries = Object.entries(mergedModelServices)
+  const modelToService = new Map<string, string>()
+  const availableModels: string[] = []
+  for (const [serviceKey, serviceValue] of serviceEntries) {
+    const service = (serviceValue != null && typeof serviceValue === 'object')
+      ? serviceValue as ModelServiceConfig
+      : undefined
+    const models = Array.isArray(service?.models)
+      ? service?.models.filter(item => typeof item === 'string' && item.trim() !== '')
+      : []
+    for (const model of models) {
+      if (!modelToService.has(model)) modelToService.set(model, serviceKey)
+      availableModels.push(model)
+    }
+  }
+
+  const resolveDefaultModel = () => {
+    if (availableModels.length === 0) return undefined
+    if (mergedDefaultModel && modelToService.has(mergedDefaultModel)) return mergedDefaultModel
+    if (mergedDefaultModelService && mergedModelServices[mergedDefaultModelService]) {
+      const service = mergedModelServices[mergedDefaultModelService]
+      const models = Array.isArray(service?.models)
+        ? service?.models.filter(item => typeof item === 'string' && item.trim() !== '')
+        : []
+      if (models.length > 0) return models[0]
+    }
+    return availableModels[0]
+  }
+
+  const resolvedModel = inputModel ?? resolveDefaultModel()
+  if (!resolvedModel) return undefined
+
+  const resolvedService = modelToService.get(resolvedModel) ??
+    mergedDefaultModelService ??
+    serviceEntries[0]?.[0]
+
+  return resolvedService ? `${resolvedService},${resolvedModel}` : resolvedModel
+}
+
 declare module '@vibe-forge/core' {
   interface Cache {
     base: Omit<AdapterCtx, 'logger' | 'cache'>
@@ -25,12 +97,6 @@ export const run = async (
 
   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
@@ -52,47 +118,52 @@ export const run = async (
       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)
+      const { data } = event
+
+      void callHook('TaskStop', {
+        adapter: adapterType,
+        cwd: ctx.cwd,
+        sessionId: adapterOptions.sessionId,
+
+        options,
+        adapterOptions,
+
+        exitCode: data.exitCode,
+        stderr: data.stderr
+      }, ctx.env)
+        .catch((e) => {
+          logger.error('[Hook] TaskStop failed', e)
+        })
     }
     originalOnEvent(event)
   }
 
   const adapter = await loadAdapter(adapterType)
+  const resolvedModel = resolveQueryModel({
+    config,
+    userConfig,
+    inputModel: adapterOptions.model
+  })
+
+  await callHook('TaskStart', {
+    adapter: adapterType,
+    cwd: ctx.cwd,
+    sessionId: adapterOptions.sessionId,
+
+    options,
+    adapterOptions
+  }, ctx.env)
   const session = await adapter.query(
     ctx,
     {
       ...adapterOptions,
+      model: resolvedModel,
       onEvent: wrappedOnEvent
     }
   )
 
-  if (session.pid) {
-    detail.pid = session.pid
-    await saveDetail(detail)
-  }
-
   return { session, ctx }
 }

package/src/env.ts

@@ -8,6 +8,9 @@ export interface ServerEnv {
   __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_CLIENT_MODE__?: 'dev' | 'static'
+  __VF_PROJECT_AI_CLIENT_BASE__?: string
+  __VF_PROJECT_AI_CLIENT_DIST_PATH__?: string
   __VF_PROJECT_AI_ADAPTER_CLAUDE_CODE_CLI_PATH__?: string
   __VF_PROJECT_AI_ADAPTER_CLAUDE_CODE_CLI_ARGS__?: string
 }
@@ -21,6 +24,9 @@ export function loadEnv(): ServerEnv {
     __VF_PROJECT_AI_SERVER_LOG_DIR__ = '.logs',
     __VF_PROJECT_AI_SERVER_LOG_LEVEL__ = 'info',
     __VF_PROJECT_AI_SERVER_ALLOW_CORS__,
+    __VF_PROJECT_AI_CLIENT_MODE__ = 'static',
+    __VF_PROJECT_AI_CLIENT_BASE__,
+    __VF_PROJECT_AI_CLIENT_DIST_PATH__,
 
     __VF_PROJECT_AI_ADAPTER_CLAUDE_CODE_CLI_PATH__,
     __VF_PROJECT_AI_ADAPTER_CLAUDE_CODE_CLI_ARGS__
@@ -36,6 +42,10 @@ export function loadEnv(): ServerEnv {
     __VF_PROJECT_AI_SERVER_ALLOW_CORS__: __VF_PROJECT_AI_SERVER_ALLOW_CORS__ != null
       ? __VF_PROJECT_AI_SERVER_ALLOW_CORS__ === 'true'
       : true,
+    __VF_PROJECT_AI_CLIENT_MODE__:
+      __VF_PROJECT_AI_CLIENT_MODE__ as ServerEnv['__VF_PROJECT_AI_CLIENT_MODE__'],
+    __VF_PROJECT_AI_CLIENT_BASE__,
+    __VF_PROJECT_AI_CLIENT_DIST_PATH__,
 
     __VF_PROJECT_AI_ADAPTER_CLAUDE_CODE_CLI_PATH__,
     __VF_PROJECT_AI_ADAPTER_CLAUDE_CODE_CLI_ARGS__

package/src/hooks/type.ts

@@ -1,3 +1,5 @@
+import type { ToolInput, ToolOutput } from '../tools'
+
 /**
  * https://docs.anthropic.com/en/docs/claude-code/hooks#hook-input
  */
@@ -5,96 +7,8 @@ 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
@@ -113,6 +27,34 @@ export interface HookInputs {
   SessionEnd: HookInputCore & {
     reason: 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]
@@ -168,6 +110,11 @@ export interface HookOutputs {
   SessionEnd: HookOutputCore
   SubagentStop: HookOutputCore
   PreCompact: HookOutputCore
+
+  StartTasks: HookOutputCore
+  GenerateSystemPrompt: HookOutputCore
+  TaskStart: HookOutputCore
+  TaskStop: HookOutputCore
 }
 
 export type HookOutput = HookOutputs[keyof HookOutputs]

package/src/index.ts

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

package/src/tools.ts

@@ -0,0 +1,46 @@
+export interface StopTaskToolInput {
+  task_id?: string
+}
+
+export interface StartTasksToolInput {
+  tasks: Array<{
+    description?: string
+    type?: 'default' | 'spec' | 'entity'
+    name?: string
+    adapter?: string
+    permissionMode?: 'default' | 'acceptEdits' | 'plan' | 'dontAsk' | 'bypassPermissions'
+    background?: boolean
+  }>
+}
+
+export interface GetTaskInfoToolInput {
+  taskId: string
+}
+
+export interface ListTasksToolInput {}
+
+export interface ToolInputs {
+  StartTasks: StartTasksToolInput
+  GetTaskInfo: GetTaskInfoToolInput
+  ListTasks: ListTasksToolInput
+  StopTask: StopTaskToolInput
+}
+
+export interface ToolOutputs {}
+
+export type ToolName = keyof ToolInputs
+
+export type ToolInput = keyof ToolInputs extends infer Keys ? Keys extends infer Key extends keyof ToolInputs ? {
+      toolName: Key
+      toolInput: ToolInputs[Key]
+    }
+  : never
+  : never
+
+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

package/src/types.ts

@@ -25,6 +25,7 @@ export interface Session {
 
 export type ChatMessageContent =
   | { type: 'text'; text: string }
+  | { type: 'image'; url: string; name?: string; size?: number; mimeType?: string }
   | { type: 'tool_use'; id: string; name: string; input: any }
   | { type: 'tool_result'; tool_use_id: string; content: any; is_error?: boolean }
 
@@ -60,7 +61,7 @@ export interface TaskDetail {
   startTime: number
   endTime?: number
   description?: string
-  adapter: string
+  adapterType?: string
   model?: string
   exitCode?: number
 }

package/src/utils/api.ts

@@ -0,0 +1,32 @@
+import process from 'node:process'
+
+import type { HookInputs, HookOutputs } from '#~/hooks/type.js'
+
+export type HookEventName = keyof HookInputs
+
+type HookInputPayload<K extends HookEventName> = Omit<HookInputs[K], 'hookEventName'>
+
+const host = process.env.__VF_PROJECT_AI_SERVER_HOST__ ?? 'localhost'
+const port = process.env.__VF_PROJECT_AI_SERVER_PORT__ ?? '8787'
+const baseUrl = `http://${host}:${port}`
+
+export const callHook = async <K extends HookEventName>(
+  hookEventName: K,
+  input: HookInputPayload<K>,
+  env: Record<string, unknown> = process.env
+): Promise<HookOutputs[K]> => {
+  const response = await fetch(`${baseUrl}/api/hooks/call`, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify({
+      hookEventName,
+      input,
+      env
+    })
+  })
+  if (!response.ok) {
+    const errorText = await response.text()
+    throw new Error(`Failed to call hook: ${response.statusText} - ${errorText}`)
+  }
+  return response.json()
+}