@vibe-forge/workspace-assets 0.9.1-alpha.0 → 0.9.2-alpha.0

package/src/prompt-selection.ts

@@ -1,139 +1,179 @@
-import { basename, dirname } from 'node:path'
-
-import { DefinitionLoader } from '@vibe-forge/definition-loader'
 import type {
+  Definition,
   Filter,
-  PromptAssetResolution,
-  ResolvedPromptAssetOptions,
+  PluginOverlayConfig,
+  Rule,
+  RuleReference,
+  SkillSelection,
   WorkspaceAsset,
   WorkspaceAssetBundle,
+  WorkspaceMcpSelection,
   WorkspaceSkillSelection
 } from '@vibe-forge/types'
 
+import { resolveWorkspaceAssetBundle } from './bundle'
 import {
-  dedupeSkillAssets,
-  filterSkillAssets,
-  pickEntityAsset,
-  pickSpecAsset,
-  resolveExcludedSkillNames,
-  resolveIncludedSkillNames,
-  resolveRulePatterns,
-  resolveSelectedRuleAssets,
-  toDocumentDefinitions,
-  toPromptAssetIds
-} from './document-assets'
-
-export async function resolvePromptAssetSelection(
-  params: {
-    bundle: WorkspaceAssetBundle
-    type: 'spec' | 'entity' | undefined
-    name?: string
-    input?: {
-      skills?: WorkspaceSkillSelection
-    }
+  generateEntitiesRoutePrompt,
+  generateRulesPrompt,
+  generateSkillsPrompt,
+  generateSkillsRoutePrompt,
+  generateSpecRoutePrompt
+} from './prompt-builders'
+import {
+  definitionWithResolvedName,
+  pickDocumentAsset,
+  resolveExcludedSkillRefs,
+  resolveIncludedSkillRefs,
+  resolveNamedAssets,
+  resolvePluginOverlay,
+  resolveRuleSelection,
+  resolveSelectedSkillAssets,
+  toDocumentDefinitions
+} from './selection-internal'
+
+export async function resolvePromptAssetSelection(params: {
+  bundle: WorkspaceAssetBundle
+  type: 'spec' | 'entity' | undefined
+  name?: string
+  input?: {
+    skills?: WorkspaceSkillSelection
+  }
+}) {
+  const options: {
+    systemPrompt?: string
+    tools?: Filter
+    mcpServers?: WorkspaceMcpSelection
+    promptAssetIds?: string[]
+    assetBundle?: WorkspaceAssetBundle
+  } = {
+    assetBundle: params.bundle
   }
-): Promise<[PromptAssetResolution, ResolvedPromptAssetOptions]> {
-  const loader = new DefinitionLoader(params.bundle.cwd)
-  const options: ResolvedPromptAssetOptions = {}
-  const systemPromptParts: string[] = []
-
-  const entities = params.type !== 'entity'
-    ? toDocumentDefinitions(params.bundle.entities)
-    : []
-  const skills = toDocumentDefinitions(
-    filterSkillAssets(params.bundle.skills, params.input?.skills)
-  )
-  const rules = toDocumentDefinitions(params.bundle.rules)
-  const specs = toDocumentDefinitions(params.bundle.specs)
-
-  const promptAssetIds = new Set<string>([
-    ...toPromptAssetIds(params.bundle.rules),
-    ...(params.type !== 'entity' ? toPromptAssetIds(params.bundle.entities) : []),
-    ...toPromptAssetIds(params.bundle.specs),
-    ...toPromptAssetIds(filterSkillAssets(params.bundle.skills, params.input?.skills))
-  ])
 
-  const targetSkillsAssets: Array<Extract<WorkspaceAsset, { kind: 'skill' }>> = []
+  let effectiveBundle = params.bundle
+  let pinnedTargetAsset: Extract<WorkspaceAsset, { kind: 'spec' | 'entity' }> | undefined
   let targetBody = ''
   let targetToolsFilter: Filter | undefined
   let targetMcpServersFilter: Filter | undefined
-  let selectedSkillAssets: Array<Extract<WorkspaceAsset, { kind: 'skill' }>> = []
-
-  if (params.input?.skills?.include != null && params.input.skills.include.length > 0) {
-    selectedSkillAssets = dedupeSkillAssets(
-      filterSkillAssets(params.bundle.skills, { include: params.input.skills.include })
-    )
-  }
+  let targetInstancePath: string | undefined
 
   if (params.type && params.name) {
-    const targetAsset = params.type === 'spec'
-      ? pickSpecAsset(params.bundle, params.name)
-      : pickEntityAsset(params.bundle, params.name)
-
-    if (targetAsset == null) {
+    const baseTarget = params.type === 'spec'
+      ? pickDocumentAsset(params.bundle.specs, params.name)
+      : pickDocumentAsset(params.bundle.entities, params.name)
+    if (baseTarget == null) {
       throw new Error(`Failed to load ${params.type} ${params.name}`)
     }
 
-    const { definition } = targetAsset.payload
-    const { attributes, body } = definition
-    promptAssetIds.add(targetAsset.id)
+    const pluginOverlay = baseTarget.payload.definition.attributes.plugins as PluginOverlayConfig | undefined
+    if (pluginOverlay != null) {
+      effectiveBundle = await resolveWorkspaceAssetBundle({
+        cwd: params.bundle.cwd,
+        plugins: resolvePluginOverlay(params.bundle.pluginConfigs, pluginOverlay),
+        overlaySource: `${params.type}:${baseTarget.displayName}`
+      })
+    }
+
+    pinnedTargetAsset = baseTarget
+    targetBody = baseTarget.payload.definition.body
+    targetToolsFilter = baseTarget.payload.definition.attributes.tools
+    targetMcpServersFilter = baseTarget.payload.definition.attributes.mcpServers
+    targetInstancePath = baseTarget.instancePath
+    options.assetBundle = effectiveBundle
+  }
 
-    if (attributes.rules) {
-      const matchedRuleAssets = await resolveSelectedRuleAssets(params.bundle, resolveRulePatterns(attributes.rules))
-      rules.push(
-        ...matchedRuleAssets.map((asset) => ({
-          ...asset.payload.definition,
-          attributes: {
-            ...asset.payload.definition.attributes,
-            always: true
-          }
-        }))
+  const selectedSkillAssets = resolveSelectedSkillAssets(effectiveBundle.skills, params.input?.skills)
+  const promptAssetIds = new Set<string>([
+    ...effectiveBundle.rules.map(asset => asset.id),
+    ...effectiveBundle.specs.map(asset => asset.id),
+    ...selectedSkillAssets.map(asset => asset.id),
+    ...(params.type !== 'entity' ? effectiveBundle.entities.map(asset => asset.id) : [])
+  ])
+  const ruleDefinitions = new Map<string, Definition<Rule>>(
+    effectiveBundle.rules.map(asset => [
+      asset.id,
+      definitionWithResolvedName(asset.payload.definition, asset.displayName, asset.instancePath)
+    ])
+  )
+  const targetSkillsAssets: Array<Extract<WorkspaceAsset, { kind: 'skill' }>> = []
+
+  if (pinnedTargetAsset != null) {
+    promptAssetIds.add(pinnedTargetAsset.id)
+    const attributes = pinnedTargetAsset.payload.definition.attributes
+
+    if (attributes.rules != null) {
+      const selection = await resolveRuleSelection(
+        effectiveBundle,
+        attributes.rules as RuleReference[] | string[],
+        targetInstancePath
       )
-      for (const asset of matchedRuleAssets) {
+      for (const asset of selection.assets) {
         promptAssetIds.add(asset.id)
+        ruleDefinitions.set(
+          asset.id,
+          definitionWithResolvedName(
+            {
+              ...asset.payload.definition,
+              attributes: {
+                ...asset.payload.definition.attributes,
+                always: true
+              }
+            },
+            asset.displayName,
+            asset.instancePath
+          )
+        )
       }
+      selection.remoteDefinitions.forEach((definition) => {
+        ruleDefinitions.set(definition.path, definition)
+      })
     }
 
-    if (attributes.skills) {
-      const includedSkillNames = new Set(resolveIncludedSkillNames(attributes.skills))
-      const excludedSkillNames = new Set(resolveExcludedSkillNames(attributes.skills))
-      for (const skillAsset of params.bundle.skills) {
-        const skillName = basename(dirname(skillAsset.payload.definition.path))
-        if (includedSkillNames.size > 0 && !includedSkillNames.has(skillName)) continue
-        if (excludedSkillNames.has(skillName)) continue
-        targetSkillsAssets.push(skillAsset)
-        promptAssetIds.add(skillAsset.id)
-      }
-    }
+    const skillSelection = attributes.skills as string[] | SkillSelection | undefined
+    const includedRefs = resolveIncludedSkillRefs(skillSelection)
+    const excludedRefs = resolveExcludedSkillRefs(skillSelection)
+    const includedAssets = skillSelection == null
+      ? []
+      : includedRefs != null
+      ? (includedRefs.length > 0 ? resolveNamedAssets(effectiveBundle.skills, includedRefs, targetInstancePath) : [])
+      : effectiveBundle.skills
+    const excludedIds = new Set(
+      resolveNamedAssets(effectiveBundle.skills, excludedRefs, targetInstancePath).map(asset => asset.id)
+    )
 
-    targetBody = body
-    targetToolsFilter = attributes.tools
-    targetMcpServersFilter = attributes.mcpServers
+    includedAssets
+      .filter(asset => !excludedIds.has(asset.id))
+      .forEach((asset) => {
+        targetSkillsAssets.push(asset)
+        promptAssetIds.add(asset.id)
+      })
   }
 
+  const rules = Array.from(ruleDefinitions.values())
   const targetSkills = toDocumentDefinitions(targetSkillsAssets)
-  const selectedSkillsPrompt = toDocumentDefinitions(
-    selectedSkillAssets.filter(
-      skill => !targetSkillsAssets.some(target => target.payload.definition.path === skill.payload.definition.path)
-    )
+  const routedSkills = toDocumentDefinitions(
+    selectedSkillAssets.filter(skill => !targetSkillsAssets.some(target => target.id === skill.id))
   )
-
-  systemPromptParts.push(loader.generateRulesPrompt(rules))
-  systemPromptParts.push(loader.generateSkillsPrompt(targetSkills))
-  systemPromptParts.push(loader.generateSkillsPrompt(selectedSkillsPrompt))
-  systemPromptParts.push(loader.generateEntitiesRoutePrompt(entities))
-  systemPromptParts.push(loader.generateSkillsRoutePrompt(skills))
-  systemPromptParts.push(loader.generateSpecRoutePrompt(specs))
-  systemPromptParts.push(targetBody)
-
-  if (targetToolsFilter) {
+  const entities = params.type !== 'entity'
+    ? toDocumentDefinitions(effectiveBundle.entities)
+    : []
+  const skills = toDocumentDefinitions(selectedSkillAssets)
+  const specs = toDocumentDefinitions(effectiveBundle.specs)
+
+  options.systemPrompt = [
+    generateRulesPrompt(effectiveBundle.cwd, rules),
+    generateSkillsPrompt(effectiveBundle.cwd, targetSkills),
+    generateEntitiesRoutePrompt(entities),
+    generateSkillsRoutePrompt(effectiveBundle.cwd, routedSkills),
+    generateSpecRoutePrompt(specs, { active: params.type === 'spec' }),
+    targetBody
+  ].join('\n\n')
+
+  if (targetToolsFilter != null) {
     options.tools = targetToolsFilter
   }
-  if (targetMcpServersFilter) {
+  if (targetMcpServersFilter != null) {
     options.mcpServers = targetMcpServersFilter
   }
-
-  options.systemPrompt = systemPromptParts.join('\n\n')
   options.promptAssetIds = Array.from(promptAssetIds)
 
   return [
@@ -147,5 +187,5 @@ export async function resolvePromptAssetSelection(
       promptAssetIds: Array.from(promptAssetIds)
     },
     options
-  ]
+  ] as const
 }

package/src/selection-internal.ts

@@ -0,0 +1,275 @@
+import type {
+  Definition,
+  PluginConfig,
+  PluginOverlayConfig,
+  Rule,
+  RuleReference,
+  SkillSelection,
+  WorkspaceAsset,
+  WorkspaceAssetBundle,
+  WorkspaceAssetKind,
+  WorkspaceMcpSelection,
+  WorkspaceSkillSelection
+} from '@vibe-forge/types'
+import { normalizePath } from '@vibe-forge/utils'
+import { mergePluginConfigs, normalizePluginConfig } from '@vibe-forge/utils/plugin-resolver'
+import { glob } from 'fast-glob'
+
+import {
+  createRemoteRuleDefinition,
+  isLocalRuleReference,
+  isPathLikeReference,
+  isRemoteRuleReference,
+  parseScopedReference
+} from '@vibe-forge/definition-core'
+
+type DocumentAssetKind = Extract<WorkspaceAssetKind, 'rule' | 'spec' | 'entity' | 'skill'>
+type DocumentAsset<TDefinition> = Extract<WorkspaceAsset, { kind: DocumentAssetKind }> & {
+  payload: {
+    definition: TDefinition & { path: string }
+  }
+}
+
+const ASSET_REFERENCE_PATH_SUFFIXES = ['.md', '.json', '.yaml', '.yml']
+
+export const definitionWithResolvedName = <TDefinition>(
+  definition: Definition<TDefinition>,
+  resolvedName: string,
+  instancePath?: string
+) => ({
+  ...definition,
+  resolvedName,
+  resolvedInstancePath: instancePath
+})
+
+export const toDocumentDefinitions = <TDefinition>(
+  assets: Array<DocumentAsset<TDefinition>>
+) =>
+  assets.map(asset =>
+    definitionWithResolvedName(
+      asset.payload.definition,
+      asset.displayName,
+      asset.instancePath
+    )
+  )
+
+const resolveUniqueAssetByName = <TAsset extends Extract<WorkspaceAsset, { kind: DocumentAssetKind }>>(
+  assets: TAsset[],
+  name: string
+) => {
+  const matches = assets.filter(asset => asset.name === name)
+  if (matches.length === 0) return undefined
+  const unscopedMatches = matches.filter(asset => asset.scope == null)
+  if (unscopedMatches.length === 1) {
+    return unscopedMatches[0]
+  }
+  if (matches.length > 1) {
+    throw new Error(
+      `Ambiguous asset reference ${name}. Candidates: ${matches.map(match => match.displayName).join(', ')}`
+    )
+  }
+  return matches[0]
+}
+
+const resolveScopedAsset = <TAsset extends Extract<WorkspaceAsset, { kind: DocumentAssetKind }>>(
+  assets: TAsset[],
+  scope: string,
+  name: string
+) => assets.find(asset => asset.scope === scope && asset.name === name)
+
+export const findNamedAsset = <TAsset extends Extract<WorkspaceAsset, { kind: DocumentAssetKind }>>(
+  assets: TAsset[],
+  ref: string,
+  currentInstancePath?: string
+) => {
+  const scoped = parseScopedReference(ref, { pathSuffixes: ASSET_REFERENCE_PATH_SUFFIXES })
+  if (scoped != null) {
+    return resolveScopedAsset(assets, scoped.scope, scoped.name)
+  }
+
+  if (currentInstancePath != null) {
+    const local = assets.find(asset => asset.instancePath === currentInstancePath && asset.name === ref)
+    if (local != null) {
+      return local
+    }
+  }
+
+  return resolveUniqueAssetByName(assets, ref)
+}
+
+export const resolveNamedAssets = <TAsset extends Extract<WorkspaceAsset, { kind: DocumentAssetKind }>>(
+  assets: TAsset[],
+  refs: string[] | undefined,
+  currentInstancePath?: string
+) => {
+  if (refs == null || refs.length === 0) return [] as TAsset[]
+
+  const selected: TAsset[] = []
+  const seen = new Set<string>()
+
+  const add = (asset: TAsset) => {
+    if (seen.has(asset.id)) return
+    seen.add(asset.id)
+    selected.push(asset)
+  }
+
+  for (const ref of refs) {
+    const asset = findNamedAsset(assets, ref, currentInstancePath)
+    if (asset == null) throw new Error(`Failed to resolve asset ${ref}`)
+    add(asset)
+  }
+
+  return selected
+}
+
+const resolvePathMatchedRules = async (
+  bundle: WorkspaceAssetBundle,
+  ref: string
+) => {
+  const matchedPaths = new Set(
+    (await glob(ref, {
+      cwd: bundle.cwd,
+      absolute: true
+    })).map(normalizePath)
+  )
+  return bundle.rules.filter(rule => matchedPaths.has(normalizePath(rule.sourcePath)))
+}
+
+export const resolveRuleSelection = async (
+  bundle: WorkspaceAssetBundle,
+  refs: RuleReference[] | string[] | undefined,
+  currentInstancePath?: string
+) => {
+  const assets: Array<Extract<WorkspaceAsset, { kind: 'rule' }>> = []
+  const remoteDefinitions: Definition<Rule>[] = []
+  const seen = new Set<string>()
+
+  const addAsset = (asset: Extract<WorkspaceAsset, { kind: 'rule' }>) => {
+    if (seen.has(asset.id)) return
+    seen.add(asset.id)
+    assets.push(asset)
+  }
+
+  let remoteIndex = 0
+  for (const ref of refs ?? []) {
+    if (isRemoteRuleReference(ref)) {
+      remoteDefinitions.push(createRemoteRuleDefinition(ref, remoteIndex++))
+      continue
+    }
+
+    const value = typeof ref === 'string'
+      ? ref
+      : isLocalRuleReference(ref)
+      ? ref.path
+      : undefined
+    if (value == null) continue
+    if (
+      isPathLikeReference(value, {
+        pathSuffixes: ASSET_REFERENCE_PATH_SUFFIXES,
+        allowGlob: true
+      })
+    ) {
+      const matched = await resolvePathMatchedRules(bundle, value)
+      matched.forEach(addAsset)
+      continue
+    }
+
+    const asset = findNamedAsset(bundle.rules, value, currentInstancePath)
+    if (asset == null) throw new Error(`Failed to resolve rule ${value}`)
+    addAsset(asset)
+  }
+
+  return {
+    assets,
+    remoteDefinitions
+  }
+}
+
+export const resolveIncludedSkillRefs = (selection: string[] | SkillSelection | undefined) => {
+  if (selection == null) return undefined
+  if (Array.isArray(selection)) return selection
+  return selection.type === 'include' ? selection.list : undefined
+}
+
+export const resolveExcludedSkillRefs = (selection: string[] | SkillSelection | undefined) => {
+  if (selection == null || Array.isArray(selection)) return undefined
+  return selection.type === 'exclude' ? selection.list : undefined
+}
+
+export const resolveSelectedSkillAssets = (
+  assets: Array<Extract<WorkspaceAsset, { kind: 'skill' }>>,
+  selection?: WorkspaceSkillSelection
+) => {
+  if (selection == null) return assets
+
+  const included = selection.include != null && selection.include.length > 0
+    ? resolveNamedAssets(assets, selection.include)
+    : assets
+  const excluded = new Set(
+    resolveNamedAssets(assets, selection.exclude).map(asset => asset.id)
+  )
+  return included.filter(asset => !excluded.has(asset.id))
+}
+
+export const resolveSelectedMcpNames = (
+  bundle: WorkspaceAssetBundle,
+  selection: WorkspaceMcpSelection | undefined
+) => {
+  const allAssets = Object.values(bundle.mcpServers)
+  const includeRefs = selection?.include ??
+    (bundle.defaultIncludeMcpServers.length > 0 ? bundle.defaultIncludeMcpServers : undefined)
+  const excludeRefs = selection?.exclude ??
+    (
+      selection?.include == null && bundle.defaultExcludeMcpServers.length > 0
+        ? bundle.defaultExcludeMcpServers
+        : undefined
+    )
+
+  const resolveRefs = (refs: string[] | undefined) => {
+    if (refs == null || refs.length === 0) return undefined
+    return new Set(refs.map((ref) => {
+      const scoped = parseScopedReference(ref, { pathSuffixes: ASSET_REFERENCE_PATH_SUFFIXES })
+      if (scoped != null) {
+        const asset = allAssets.find(item => item.scope === scoped.scope && item.name === scoped.name)
+        if (asset == null) throw new Error(`Failed to resolve MCP server ${ref}`)
+        return asset.displayName
+      }
+
+      const matches = allAssets.filter(item => item.name === ref || item.displayName === ref)
+      if (matches.length === 0) throw new Error(`Failed to resolve MCP server ${ref}`)
+      if (matches.length > 1) {
+        throw new Error(
+          `Ambiguous MCP server reference ${ref}. Candidates: ${matches.map(match => match.displayName).join(', ')}`
+        )
+      }
+      return matches[0].displayName
+    }))
+  }
+
+  const include = resolveRefs(includeRefs)
+  const exclude = resolveRefs(excludeRefs) ?? new Set<string>()
+
+  return allAssets
+    .map(asset => asset.displayName)
+    .filter(name => (include == null || include.has(name)) && !exclude.has(name))
+}
+
+export const resolvePluginOverlay = (
+  basePlugins: PluginConfig | undefined,
+  overlay: PluginOverlayConfig | undefined
+) => {
+  if (overlay == null) return basePlugins
+  if (overlay.mode !== 'override' && overlay.mode !== 'extend') {
+    throw new Error('Invalid plugins overlay. "mode" must be "extend" or "override".')
+  }
+
+  const overlayList = normalizePluginConfig(overlay.list, 'plugins overlay list') ?? []
+  return overlay.mode === 'override'
+    ? overlayList
+    : mergePluginConfigs(basePlugins, overlayList)
+}
+
+export const pickDocumentAsset = <TAsset extends Extract<WorkspaceAsset, { kind: 'spec' | 'entity' }>>(
+  assets: TAsset[],
+  ref: string
+) => findNamedAsset(assets, ref)