@vibe-forge/core 0.7.0 → 0.7.3

package/package.json

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

package/src/adapter/type.ts

@@ -6,10 +6,18 @@ import type { ChatMessage, ChatMessageContent } from '../types'
 
 export type AdapterMessageContent = ChatMessageContent
 
+export interface AdapterErrorData {
+  message: string
+  code?: string
+  details?: unknown
+  fatal?: boolean
+}
+
 export type AdapterOutputEvent =
   | { type: 'init'; data: SessionInitInfo }
   | { type: 'summary'; data: SessionSummaryInfo }
   | { type: 'message'; data: ChatMessage }
+  | { type: 'error'; data: AdapterErrorData }
   | { type: 'exit'; data: { exitCode?: number; stderr?: string } }
   | { type: 'stop'; data?: ChatMessage }
 

package/src/config/types.ts

@@ -34,6 +34,20 @@ export interface ModelServiceConfig {
    * 模型服务支持的模型别名
    */
   modelsAlias?: Record<string, string[]>
+  /**
+   * 模型服务超时（毫秒）。
+   * - Codex: 映射为 `stream_idle_timeout_ms`
+   * - Claude Code Router: 映射为全局 `API_TIMEOUT_MS`
+   * - OpenCode: 映射为 provider `timeout` / `chunkTimeout`
+   */
+  timeoutMs?: number
+  /**
+   * 模型服务默认最大输出 token。
+   * - Codex: 映射为 `turn/start.maxOutputTokens`
+   * - Claude Code Router: 映射为 `maxtoken` transformer
+   * - OpenCode: 映射为 model `options.maxOutputTokens` / `limit.output`
+   */
+  maxOutputTokens?: number
   /**
    * 拓展配置，由下游自行消费
    */
@@ -178,6 +192,12 @@ export interface Config {
      * 自定义对话风格。通过指定提示词约束对话风格。
      */
     customInstructions?: string
+    /**
+     * 是否注入 Vibe Forge 自动生成的默认系统提示词
+     * （例如 rules / skills / entities / specs 生成的提示词）。
+     * 默认为 true。
+     */
+    injectDefaultSystemPrompt?: boolean
   }
   /**
    * 插件配置

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

@@ -1,24 +1,122 @@
 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, Filter, Skill } 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 ?? []
+}
 
 export async function generateAdapterQueryOptions(
   type: 'spec' | 'entity' | undefined,
   name?: string,
-  cwd: string = process.cwd()
+  cwd: string = process.cwd(),
+  input?: {
+    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 skills = await loader.loadDefaultSkills()
+  const defaultSkills = await loader.loadDefaultSkills()
   const rules = await loader.loadDefaultRules()
   const specs = await loader.loadDefaultSpecs()
 
@@ -42,7 +140,9 @@ export async function generateAdapterQueryOptions(
       // always load spec or entity tagged rules
       rules.push(
         ...(
-          await loader.loadRules(attributes.rules)
+          await loader.loadRules(attributes.rules, {
+            baseDir: dirname(data.path)
+          })
         ).map((rule) => ({
           ...rule,
           attributes: {
@@ -56,18 +156,40 @@ export async function generateAdapterQueryOptions(
     if (
       attributes.skills
     ) {
-      targetSkills.push(...await loader.loadSkills(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(targetSkills))
+  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))

package/src/utils/definition-loader.ts

@@ -36,6 +36,25 @@ export interface Spec {
   tools?: Filter
 }
 
+export interface LocalRuleReference {
+  type?: 'local'
+  path: string
+  desc?: string
+}
+
+export interface RemoteRuleReference {
+  type: 'remote'
+  tags?: string[]
+  desc?: string
+}
+
+export type RuleReference = string | LocalRuleReference | RemoteRuleReference
+
+export interface SkillSelection {
+  type: 'include' | 'exclude'
+  list: string[]
+}
+
 export interface Entity {
   name?: string
   always?: boolean
@@ -43,8 +62,8 @@ export interface Entity {
   tags?: string[]
   prompt?: string
   promptPath?: string
-  rules?: string[]
-  skills?: string[]
+  rules?: RuleReference[]
+  skills?: string[] | SkillSelection
   mcpServers?: Filter
   tools?: Filter
 }
@@ -123,6 +142,66 @@ const resolveSpecIdentifier = (path: string, explicitName?: string) => {
   return resolveDocumentName(path, explicitName, ['index.md'])
 }
 
+const toNonEmptyStringArray = (values: unknown): string[] => {
+  if (!Array.isArray(values)) return []
+  return values
+    .filter((value): value is string => typeof value === 'string')
+    .map(value => value.trim())
+    .filter(Boolean)
+}
+
+const isLocalRuleReference = (value: RuleReference): value is LocalRuleReference => {
+  return (
+    value != null &&
+    typeof value === 'object' &&
+    typeof value.path === 'string' &&
+    (value.type == null || value.type === 'local')
+  )
+}
+
+const isRemoteRuleReference = (value: RuleReference): value is RemoteRuleReference => {
+  return (
+    value != null &&
+    typeof value === 'object' &&
+    value.type === 'remote'
+  )
+}
+
+const resolveRulePattern = (pattern: string, baseDir: string) => {
+  const trimmed = pattern.trim()
+  if (!trimmed) return undefined
+  if (trimmed.startsWith('./') || trimmed.startsWith('../')) {
+    return normalizePath(resolve(baseDir, trimmed))
+  }
+  return trimmed
+}
+
+const createRemoteRuleDefinition = (
+  rule: RemoteRuleReference,
+  index: number
+): Definition<Rule> => {
+  const tags = toNonEmptyStringArray(rule.tags)
+  const desc = rule.desc?.trim() || (
+    tags.length > 0
+      ? `远程知识库标签：${tags.join(', ')}`
+      : '远程知识库规则引用'
+  )
+  const bodyParts = [
+    desc,
+    tags.length > 0 ? `知识库标签：${tags.join(', ')}` : undefined,
+    '该规则来自远程知识库引用，不对应本地文件。'
+  ].filter((value): value is string => Boolean(value))
+
+  return {
+    path: `remote-rule-${index + 1}.md`,
+    body: bodyParts.join('\n'),
+    attributes: {
+      name: tags.length > 0 ? `remote:${tags.join(',')}` : `remote-rule-${index + 1}`,
+      description: desc
+    }
+  }
+}
+
 export class DefinitionLoader {
   private readonly cwd: string
 
@@ -142,10 +221,53 @@ export class DefinitionLoader {
     })
   }
 
-  async loadRules(rules: string[]) {
-    return loadLocalDocuments<Rule>(
-      await this.scan(rules)
-    )
+  async loadRules(
+    rules: RuleReference[],
+    options?: {
+      baseDir?: string
+    }
+  ) {
+    const baseDir = options?.baseDir ?? this.cwd
+    const definitions: Definition<Rule>[] = []
+
+    for (const [index, rule] of rules.entries()) {
+      if (typeof rule === 'string') {
+        const pattern = resolveRulePattern(rule, baseDir)
+        if (!pattern) continue
+        definitions.push(
+          ...await loadLocalDocuments<Rule>(
+            await this.scan([pattern])
+          )
+        )
+        continue
+      }
+
+      if (isRemoteRuleReference(rule)) {
+        definitions.push(createRemoteRuleDefinition(rule, index))
+        continue
+      }
+
+      if (!isLocalRuleReference(rule)) continue
+
+      const pattern = resolveRulePattern(rule.path, baseDir)
+      if (!pattern) continue
+
+      const docs = await loadLocalDocuments<Rule>(
+        await this.scan([pattern])
+      )
+
+      definitions.push(
+        ...docs.map((doc) => ({
+          ...doc,
+          attributes: {
+            ...doc.attributes,
+            description: rule.desc?.trim() || doc.attributes.description
+          }
+        }))
+      )
+    }
+
+    return definitions
   }
   async loadDefaultRules(): Promise<Definition<Rule>[]> {
     return this.loadRules([

package/src/ws.ts

@@ -1,8 +1,8 @@
-import type { SessionInfo } from './adapter/index.js'
+import type { AdapterErrorData, SessionInfo } from './adapter/index.js'
 import type { AskUserQuestionParams, ChatMessage } from './types.js'
 
 export type WSEvent =
-  | { type: 'error'; message: string }
+  | { type: 'error'; data: AdapterErrorData; message?: string }
   | { type: 'message'; message: ChatMessage }
   | { type: 'session_info'; info: SessionInfo }
   | { type: 'tool_result'; toolCallId: string; output: any; isError: boolean }