@vibe-forge/core 0.7.4 → 0.7.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vibe-forge/core",
-  "version": "0.7.4",
+  "version": "0.7.5",
   "imports": {
     "#~/*.js": {
       "__vibe-forge__": {

package/src/adapter/type.ts

@@ -1,6 +1,7 @@
 import type { Cache, Config } from '@vibe-forge/core'
 
 import type { Logger } from '#~/utils/create-logger.js'
+import type { AdapterAssetPlan, AssetDiagnostic, WorkspaceAssetBundle } from '#~/utils/workspace-assets.js'
 
 import type { ChatMessage, ChatMessageContent } from '../types'
 
@@ -35,6 +36,7 @@ export interface SessionInitInfo {
   cwd: string
   agents: string[]
   title?: string
+  assetDiagnostics?: AssetDiagnostic[]
 }
 
 export interface SessionSummaryInfo {
@@ -62,6 +64,7 @@ export interface AdapterCtx {
   logger: Logger
 
   configs: [Config?, Config?]
+  assets?: WorkspaceAssetBundle
 }
 
 export interface AdapterQueryOptions {
@@ -91,6 +94,8 @@ export interface AdapterQueryOptions {
   }
 
   extraOptions?: string[]
+  promptAssetIds?: string[]
+  assetPlan?: AdapterAssetPlan
 
   onEvent: (event: AdapterOutputEvent) => void
 }

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

@@ -1,102 +1,7 @@
 import process from 'node:process'
-import { basename, dirname } from 'node:path'
 
 import type { AdapterQueryOptions } from '#~/adapter/type.js'
-import { DefinitionLoader } from '#~/utils/definition-loader.js'
-import type { Definition, Entity, Filter, Skill, Spec } from '#~/utils/definition-loader.js'
-
-const filterSkills = (
-  skills: Definition<Skill>[],
-  selection?: AdapterQueryOptions['skills']
-) => {
-  if (selection == null) return skills
-
-  const include = selection.include != null && selection.include.length > 0
-    ? new Set(selection.include)
-    : undefined
-  const exclude = new Set(selection.exclude ?? [])
-
-  return skills.filter((skill) => {
-    const name = basename(dirname(skill.path))
-    return (include == null || include.has(name)) && !exclude.has(name)
-  })
-}
-
-const dedupeSkills = (skills: Definition<Skill>[]) => {
-  const seen = new Set<string>()
-  return skills.filter((skill) => {
-    if (seen.has(skill.path)) return false
-    seen.add(skill.path)
-    return true
-  })
-}
-
-type SkillSelectionInput =
-  | AdapterQueryOptions['skills']
-  | Entity['skills']
-  | Spec['skills']
-
-const toNormalizedSkillSelection = (
-  selection?: SkillSelectionInput
-): AdapterQueryOptions['skills'] | undefined => {
-  if (selection == null) return undefined
-
-  if (Array.isArray(selection)) {
-    return selection.length > 0
-      ? {
-          include: selection
-        }
-      : undefined
-  }
-
-  if ('type' in selection && Array.isArray(selection.list)) {
-    const list = selection.list.filter((item): item is string => typeof item === 'string')
-    return selection.type === 'include'
-      ? {
-          include: list
-        }
-      : {
-          exclude: list
-        }
-  }
-
-  return selection
-}
-
-const mergeSkillSelections = (
-  ...selections: Array<SkillSelectionInput | undefined>
-): AdapterQueryOptions['skills'] | undefined => {
-  let include: Set<string> | undefined
-  const exclude = new Set<string>()
-
-  for (const selection of selections) {
-    const normalized = toNormalizedSkillSelection(selection)
-    if (normalized == null) continue
-
-    if (normalized.include != null && normalized.include.length > 0) {
-      const current = new Set(normalized.include)
-      include = include == null
-        ? current
-        : new Set([...include].filter(item => current.has(item)))
-    }
-
-    for (const item of normalized.exclude ?? []) {
-      exclude.add(item)
-    }
-  }
-
-  if (include == null && exclude.size === 0) return undefined
-
-  return {
-    include: include == null ? undefined : [...include],
-    exclude: exclude.size === 0 ? undefined : [...exclude]
-  }
-}
-
-const getIncludedSkillNames = (selection?: SkillSelectionInput): string[] => {
-  const normalized = toNormalizedSkillSelection(selection)
-  return normalized?.include ?? []
-}
+import { resolvePromptAssetSelection, resolveWorkspaceAssetBundle } from '#~/utils/workspace-assets.js'
 
 export async function generateAdapterQueryOptions(
   type: 'spec' | 'entity' | undefined,
@@ -106,113 +11,15 @@ export async function generateAdapterQueryOptions(
     skills?: AdapterQueryOptions['skills']
   }
 ) {
-  const loader = new DefinitionLoader(cwd)
-  const options: Partial<AdapterQueryOptions> = {}
-  const systemPromptParts: string[] = []
-  let effectiveSkillSelection = toNormalizedSkillSelection(input?.skills)
-
-  // 1. 获取数据
-  // 1.1 获取默认数据
-  const entities = type !== 'entity'
-    ? await loader.loadDefaultEntities()
-    : []
-  const defaultSkills = await loader.loadDefaultSkills()
-  const rules = await loader.loadDefaultRules()
-  const specs = await loader.loadDefaultSpecs()
-
-  // 1.2 获取指定数据
-  const targetSkills: Definition<Skill>[] = []
-  let targetBody = ''
-  let targetToolsFilter: Filter | undefined
-  let targetMcpServersFilter: Filter | undefined
-  if (type && name) {
-    const data = {
-      spec: await loader.loadSpec(name),
-      entity: await loader.loadEntity(name)
-    }[type]
-    if (!data) {
-      throw new Error(`Failed to load ${type} ${name}`)
-    }
-    const { attributes, body } = data
-    if (
-      attributes.rules
-    ) {
-      // always load spec or entity tagged rules
-      rules.push(
-        ...(
-          await loader.loadRules(attributes.rules, {
-            baseDir: dirname(data.path)
-          })
-        ).map((rule) => ({
-          ...rule,
-          attributes: {
-            ...rule.attributes,
-            // 实体或流程中的规则为默认加载
-            always: true
-          }
-        }))
-      )
-    }
-    if (
-      attributes.skills
-    ) {
-      effectiveSkillSelection = mergeSkillSelections(
-        input?.skills,
-        attributes.skills
-      )
-      targetSkills.push(
-        ...filterSkills(
-          await loader.loadSkills(getIncludedSkillNames(attributes.skills)),
-          effectiveSkillSelection
-        )
-      )
-    }
-
-    targetBody = body
-    targetToolsFilter = attributes.tools
-    targetMcpServersFilter = attributes.mcpServers
-  }
-  const skills = filterSkills(defaultSkills, effectiveSkillSelection)
-  let selectedSkillsPrompt: Definition<Skill>[] = []
-  if (input?.skills?.include != null && input.skills.include.length > 0) {
-    selectedSkillsPrompt = dedupeSkills(
-      filterSkills(
-        await loader.loadSkills(input.skills.include),
-        effectiveSkillSelection
-      )
-    )
-  }
-
-  // 2. 基于数据生成上下文
-  // 2.1 加载关联上下文
-  systemPromptParts.push(loader.generateRulesPrompt(rules))
-  systemPromptParts.push(loader.generateSkillsPrompt(dedupeSkills(targetSkills)))
-  systemPromptParts.push(loader.generateSkillsPrompt(
-    selectedSkillsPrompt.filter(skill => !targetSkills.some(target => target.path === skill.path))
-  ))
-  // 2.2 加载上下文路由
-  systemPromptParts.push(loader.generateEntitiesRoutePrompt(entities))
-  systemPromptParts.push(loader.generateSkillsRoutePrompt(skills))
-  systemPromptParts.push(loader.generateSpecRoutePrompt(specs))
-  // 2.3 加载目标上下文与配置
-  systemPromptParts.push(targetBody)
-  targetToolsFilter && (
-    options.tools = targetToolsFilter
-  )
-  targetMcpServersFilter && (
-    options.mcpServers = targetMcpServersFilter
-  )
-
-  options.systemPrompt = systemPromptParts.join('\n\n')
+  const bundle = await resolveWorkspaceAssetBundle({ cwd })
+  const [data, resolvedOptions] = await resolvePromptAssetSelection({
+    bundle,
+    type,
+    name,
+    input
+  })
   return [
-    {
-      rules,
-      targetSkills,
-      entities,
-      skills,
-      specs,
-      targetBody
-    },
-    options
+    data,
+    resolvedOptions as Partial<AdapterQueryOptions>
   ] as const
 }

package/src/controllers/task/prepare.ts

@@ -5,6 +5,7 @@ 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'
 
@@ -52,6 +53,10 @@ export const prepare = async (
     __VF_PROJECT_WORKSPACE_FOLDER__: cwd
   }
   const [config, userConfig] = await loadConfig({ jsonVariables })
+  const assets = await resolveWorkspaceAssetBundle({
+    cwd,
+    configs: [config, userConfig]
+  })
   return [
     {
       ctxId,
@@ -62,7 +67,8 @@ export const prepare = async (
         get: (key) => getCache(cwd, ctxId, sessionId, key)
       },
       logger,
-      configs: [config, userConfig]
+      configs: [config, userConfig],
+      assets
     } satisfies AdapterCtx
   ] as const
 }

package/src/controllers/task/run.ts

@@ -1,7 +1,9 @@
 import type { AdapterCtx, AdapterOutputEvent, AdapterQueryOptions } from '#~/adapter/index.js'
 import { loadAdapter } from '#~/adapter/index.js'
 import type { ModelServiceConfig } from '#~/config.js'
+import { createAdapterHookBridge } from '#~/hooks/bridge.js'
 import { callHook } from '#~/hooks/call.js'
+import { buildAdapterAssetPlan } from '#~/utils/workspace-assets.js'
 import type { TaskDetail } from '#~/types.js'
 
 import { prepare } from './prepare'
@@ -127,14 +129,54 @@ export const run = async (
       return adapterNames[0]
     })()
 
+  const adapter = await loadAdapter(adapterType)
+  await adapter.init?.(ctx)
+
+  const resolvedModel = resolveQueryModel({
+    config,
+    userConfig,
+    inputModel: adapterOptions.model
+  })
+
   const originalOnEvent = adapterOptions.onEvent
+  const supportedAssetPlanAdapters = new Set(['claude-code', 'codex', 'opencode'])
+  const assetPlan = ctx.assets == null || !supportedAssetPlanAdapters.has(adapterType)
+    ? undefined
+    : buildAdapterAssetPlan({
+        adapter: adapterType as 'claude-code' | 'codex' | 'opencode',
+        bundle: ctx.assets,
+        options: {
+          mcpServers: adapterOptions.mcpServers,
+          skills: adapterOptions.skills,
+          promptAssetIds: adapterOptions.promptAssetIds
+        }
+      })
+  const nativeBridgeDisabledEvents = adapterType === 'codex' && ctx.env.__VF_PROJECT_AI_CODEX_NATIVE_HOOKS_AVAILABLE__ === '1'
+    ? ['SessionStart', 'UserPromptSubmit', 'PreToolUse', 'PostToolUse', 'Stop']
+    : adapterType === 'claude-code' && ctx.env.__VF_PROJECT_AI_CLAUDE_NATIVE_HOOKS_AVAILABLE__ === '1'
+      ? ['SessionStart', 'UserPromptSubmit', 'PreToolUse', 'PostToolUse', 'Stop']
+      : adapterType === 'opencode' && ctx.env.__VF_PROJECT_AI_OPENCODE_NATIVE_HOOKS_AVAILABLE__ === '1'
+        ? ['SessionStart', 'PreToolUse', 'PostToolUse', 'Stop']
+        : []
+  const hookBridge = createAdapterHookBridge({
+    ctx,
+    adapter: adapterType,
+    runtime: adapterOptions.runtime,
+    sessionId: adapterOptions.sessionId,
+    type: adapterOptions.type,
+    model: resolvedModel,
+    disabledEvents: nativeBridgeDisabledEvents
+  })
   const wrappedOnEvent = (event: AdapterOutputEvent) => {
+    hookBridge.handleOutput(event)
+
     if (event.type === 'init') {
       originalOnEvent({
         ...event,
         data: {
           ...event.data,
-          adapter: adapterType
+          adapter: adapterType,
+          assetDiagnostics: assetPlan?.diagnostics ?? event.data.assetDiagnostics
         }
       })
       return
@@ -161,16 +203,7 @@ export const run = async (
     originalOnEvent(event)
   }
 
-  const adapter = await loadAdapter(adapterType)
-  await adapter.init?.(ctx)
-
-  const resolvedModel = resolveQueryModel({
-    config,
-    userConfig,
-    inputModel: adapterOptions.model
-  })
-
-  await callHook('TaskStart', {
+  const taskStartOutput = await callHook('TaskStart', {
     adapter: adapterType,
     cwd: ctx.cwd,
     sessionId: adapterOptions.sessionId,
@@ -178,14 +211,21 @@ export const run = async (
     options,
     adapterOptions
   }, ctx.env)
+  if (taskStartOutput?.continue === false) {
+    throw new Error(taskStartOutput.stopReason ?? 'TaskStart hook blocked task startup')
+  }
+  await hookBridge.start()
+  const description = await hookBridge.prepareInitialPrompt(adapterOptions.description)
   const session = await adapter.query(
     ctx,
     {
       ...adapterOptions,
+      assetPlan,
+      description,
       model: resolvedModel,
       onEvent: wrappedOnEvent
     }
   )
 
-  return { session, ctx }
+  return { session: hookBridge.wrapSession(session), ctx }
 }