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

package/src/adapter-asset-plan.ts

@@ -0,0 +1,174 @@
+import { basename, dirname } from 'node:path'
+
+import type {
+  AdapterAssetPlan,
+  AssetDiagnostic,
+  WorkspaceAssetAdapter,
+  WorkspaceAssetBundle,
+  WorkspaceMcpSelection,
+  WorkspaceSkillSelection
+} from '@vibe-forge/types'
+
+import { filterSkillAssets } from './document-assets'
+import { isOpenCodeOverlayAsset } from './internal-types'
+
+const resolveMcpServerSelection = (
+  bundle: WorkspaceAssetBundle,
+  selection: WorkspaceMcpSelection | undefined
+) => {
+  const include = selection?.include ?? (
+    bundle.defaultIncludeMcpServers.length > 0 ? bundle.defaultIncludeMcpServers : undefined
+  )
+  const exclude = selection?.exclude ?? (
+    bundle.defaultExcludeMcpServers.length > 0 ? bundle.defaultExcludeMcpServers : undefined
+  )
+
+  return {
+    include,
+    exclude
+  }
+}
+
+export function buildAdapterAssetPlan(params: {
+  adapter: WorkspaceAssetAdapter
+  bundle: WorkspaceAssetBundle
+  options: {
+    mcpServers?: WorkspaceMcpSelection
+    skills?: WorkspaceSkillSelection
+    promptAssetIds?: string[]
+  }
+}): AdapterAssetPlan {
+  const diagnostics: AssetDiagnostic[] = []
+  const promptAssetIdSet = new Set(params.options.promptAssetIds ?? [])
+  const mcpSelection = resolveMcpServerSelection(params.bundle, params.options.mcpServers)
+  const selectedMcpServerNames = Object.keys(params.bundle.mcpServers).filter((name) => {
+    if (mcpSelection.include != null && !mcpSelection.include.includes(name)) return false
+    if (mcpSelection.exclude?.includes(name)) return false
+    return true
+  })
+  const mcpServers = Object.fromEntries(
+    selectedMcpServerNames.map((name) => [name, params.bundle.mcpServers[name].payload.config])
+  )
+
+  for (const assetId of promptAssetIdSet) {
+    diagnostics.push({
+      assetId,
+      adapter: params.adapter,
+      status: 'prompt',
+      reason: 'Mapped into the generated system prompt.'
+    })
+  }
+
+  for (const name of selectedMcpServerNames) {
+    diagnostics.push({
+      assetId: params.bundle.mcpServers[name].id,
+      adapter: params.adapter,
+      status: params.adapter === 'claude-code' ? 'native' : 'translated',
+      reason: params.adapter === 'claude-code'
+        ? 'Mapped into native MCP settings.'
+        : 'Translated into adapter-specific MCP configuration.'
+    })
+  }
+
+  for (const hookPlugin of params.bundle.hookPlugins) {
+    const nativeHookReason = params.adapter === 'claude-code'
+      ? 'Mapped into the isolated Claude Code native hooks bridge under .ai/.mock/.claude/settings.json.'
+      : params.adapter === 'codex'
+      ? 'Mapped into the isolated Codex native hooks bridge for SessionStart, UserPromptSubmit, PreToolUse, PostToolUse, and Stop.'
+      : 'Mapped into the isolated OpenCode native hook plugin bridge under .ai/.mock/.config/opencode/plugins.'
+    diagnostics.push({
+      assetId: hookPlugin.id,
+      adapter: params.adapter,
+      status: 'native',
+      reason: nativeHookReason
+    })
+  }
+
+  const overlays: AdapterAssetPlan['overlays'] = []
+  if (params.adapter === 'opencode') {
+    const skillAssets = filterSkillAssets(params.bundle.skills, params.options.skills)
+    for (const skillAsset of skillAssets) {
+      overlays.push({
+        assetId: skillAsset.id,
+        kind: 'skill',
+        sourcePath: dirname(skillAsset.payload.definition.path),
+        targetPath: `skills/${basename(dirname(skillAsset.payload.definition.path))}`
+      })
+      diagnostics.push({
+        assetId: skillAsset.id,
+        adapter: 'opencode',
+        status: 'native',
+        reason: 'Mirrored into OPENCODE_CONFIG_DIR as a native skill.'
+      })
+    }
+
+    for (const asset of params.bundle.assets) {
+      if (!isOpenCodeOverlayAsset(asset)) continue
+      if (!asset.targets.includes('opencode')) continue
+
+      overlays.push({
+        assetId: asset.id,
+        kind: asset.kind,
+        sourcePath: asset.payload.sourcePath,
+        targetPath: asset.payload.targetSubpath
+      })
+      diagnostics.push({
+        assetId: asset.id,
+        adapter: 'opencode',
+        status: 'native',
+        reason: 'Mirrored into OPENCODE_CONFIG_DIR as a native OpenCode asset.'
+      })
+    }
+  }
+
+  if (params.adapter !== 'claude-code') {
+    for (const asset of params.bundle.assets) {
+      if (asset.kind !== 'nativePlugin' || !asset.enabled || !asset.targets.includes('claude-code')) continue
+      diagnostics.push({
+        assetId: asset.id,
+        adapter: params.adapter,
+        status: 'skipped',
+        reason: 'Claude marketplace plugin settings do not have a native mapping for this adapter.'
+      })
+    }
+  }
+
+  if (params.adapter === 'codex') {
+    for (const asset of params.bundle.assets) {
+      if (!['nativePlugin', 'agent', 'command', 'mode'].includes(asset.kind)) continue
+      if (asset.targets.includes('codex')) continue
+      if (asset.kind === 'nativePlugin' && asset.targets.includes('claude-code')) continue
+      diagnostics.push({
+        assetId: asset.id,
+        adapter: 'codex',
+        status: 'skipped',
+        reason: 'No stable native Codex mapping exists for this asset kind in V1.'
+      })
+    }
+  }
+
+  return {
+    adapter: params.adapter,
+    diagnostics,
+    mcpServers,
+    overlays,
+    native: params.adapter === 'claude-code'
+      ? {
+        enabledPlugins: params.bundle.enabledPlugins,
+        extraKnownMarketplaces: params.bundle.extraKnownMarketplaces
+      }
+      : params.adapter === 'codex' && params.bundle.hookPlugins.length > 0
+      ? {
+        codexHooks: {
+          supportedEvents: [
+            'SessionStart',
+            'UserPromptSubmit',
+            'PreToolUse',
+            'PostToolUse',
+            'Stop'
+          ]
+        }
+      }
+      : {}
+  }
+}

package/src/bundle.ts

@@ -0,0 +1,178 @@
+import process from 'node:process'
+
+import {
+  DEFAULT_VIBE_FORGE_MCP_SERVER_NAME,
+  buildConfigJsonVariables,
+  loadConfig,
+  resolveDefaultVibeForgeMcpServerConfig
+} from '@vibe-forge/config'
+import { DefinitionLoader } from '@vibe-forge/definition-loader'
+import type { Config, WorkspaceAsset, WorkspaceAssetBundle } from '@vibe-forge/types'
+import { resolveDocumentName, resolveSpecIdentifier } from '@vibe-forge/utils'
+
+import {
+  createDocumentAsset,
+  dedupeDocumentAssets,
+  dedupeDocumentAssetsByIdentifier,
+  resolveRuleIdentifier,
+  resolveSkillIdentifier
+} from './document-assets'
+import { mergeRecord, uniqueValues } from './helpers'
+import {
+  createClaudeNativePluginAssets,
+  createHookPluginAssets,
+  loadOpenCodeOverlayAssets,
+  loadPluginMcpAssets
+} from './plugin-assets'
+
+const readConfigForWorkspace = async (cwd: string) => {
+  return loadConfig({
+    cwd,
+    jsonVariables: buildConfigJsonVariables(cwd, process.env)
+  })
+}
+
+export async function resolveWorkspaceAssetBundle(params: {
+  cwd: string
+  configs?: [Config?, Config?]
+  useDefaultVibeForgeMcpServer?: boolean
+}): Promise<WorkspaceAssetBundle> {
+  const [config, userConfig] = params.configs ?? await readConfigForWorkspace(params.cwd)
+  const enabledPlugins = mergeRecord(config?.enabledPlugins, userConfig?.enabledPlugins)
+  const extraKnownMarketplaces = mergeRecord(config?.extraKnownMarketplaces, userConfig?.extraKnownMarketplaces)
+  const loader = new DefinitionLoader(params.cwd)
+
+  const [
+    rawRules,
+    rawSpecs,
+    rawEntities,
+    rawSkills,
+    pluginMcpAssets,
+    openCodeOverlayAssets
+  ] = await Promise.all([
+    loader.loadDefaultRules(),
+    loader.loadDefaultSpecs(),
+    loader.loadDefaultEntities(),
+    loader.loadDefaultSkills(),
+    loadPluginMcpAssets(params.cwd, enabledPlugins),
+    loadOpenCodeOverlayAssets(params.cwd, enabledPlugins)
+  ])
+
+  const assets: WorkspaceAsset[] = []
+
+  const rules = dedupeDocumentAssetsByIdentifier(
+    dedupeDocumentAssets(
+      rawRules.map((definition) => createDocumentAsset({ cwd: params.cwd, kind: 'rule', definition })),
+      enabledPlugins
+    ),
+    asset => resolveRuleIdentifier(asset.payload.definition.path, asset.payload.definition.attributes.name)
+  )
+  const specs = dedupeDocumentAssetsByIdentifier(
+    dedupeDocumentAssets(
+      rawSpecs.map((definition) => createDocumentAsset({ cwd: params.cwd, kind: 'spec', definition })),
+      enabledPlugins
+    ),
+    asset => resolveSpecIdentifier(asset.payload.definition.path, asset.payload.definition.attributes.name)
+  )
+  const entities = dedupeDocumentAssetsByIdentifier(
+    dedupeDocumentAssets(
+      rawEntities.map((definition) => createDocumentAsset({ cwd: params.cwd, kind: 'entity', definition })),
+      enabledPlugins
+    ),
+    asset =>
+      resolveDocumentName(
+        asset.payload.definition.path,
+        asset.payload.definition.attributes.name,
+        ['readme.md', 'index.json']
+      )
+  )
+  const skills = dedupeDocumentAssetsByIdentifier(
+    dedupeDocumentAssets(
+      rawSkills.map((definition) => createDocumentAsset({ cwd: params.cwd, kind: 'skill', definition })),
+      enabledPlugins
+    ),
+    asset => resolveSkillIdentifier(asset.payload.definition.path, asset.payload.definition.attributes.name)
+  )
+
+  assets.push(...rules, ...specs, ...entities, ...skills)
+
+  const mcpServers = new Map<string, Extract<WorkspaceAsset, { kind: 'mcpServer' }>>()
+  if (params.useDefaultVibeForgeMcpServer !== false) {
+    const defaultVibeForgeMcpServer = resolveDefaultVibeForgeMcpServerConfig()
+    if (defaultVibeForgeMcpServer != null) {
+      mcpServers.set(DEFAULT_VIBE_FORGE_MCP_SERVER_NAME, {
+        id: `mcpServer:fallback:${DEFAULT_VIBE_FORGE_MCP_SERVER_NAME}`,
+        kind: 'mcpServer',
+        origin: 'fallback',
+        scope: 'adapter',
+        enabled: true,
+        targets: ['claude-code', 'codex', 'opencode'],
+        payload: {
+          name: DEFAULT_VIBE_FORGE_MCP_SERVER_NAME,
+          config: defaultVibeForgeMcpServer
+        }
+      })
+    }
+  }
+  const userMcpServers = userConfig?.mcpServers ?? {}
+  for (const [name, serverConfig] of Object.entries(userMcpServers)) {
+    mcpServers.set(name, {
+      id: `mcpServer:user:${name}`,
+      kind: 'mcpServer',
+      origin: 'config',
+      scope: 'user',
+      enabled: true,
+      targets: ['claude-code', 'codex', 'opencode'],
+      payload: {
+        name,
+        config: serverConfig
+      }
+    })
+  }
+  for (const asset of pluginMcpAssets) {
+    mcpServers.set(asset.payload.name, asset)
+  }
+  for (const [name, serverConfig] of Object.entries(config?.mcpServers ?? {})) {
+    mcpServers.set(name, {
+      id: `mcpServer:project:${name}`,
+      kind: 'mcpServer',
+      origin: 'config',
+      scope: 'project',
+      enabled: true,
+      targets: ['claude-code', 'codex', 'opencode'],
+      payload: {
+        name,
+        config: serverConfig
+      }
+    })
+  }
+  assets.push(...mcpServers.values())
+
+  const hookPlugins = [
+    ...createHookPluginAssets(userConfig?.plugins, enabledPlugins, 'user'),
+    ...createHookPluginAssets(config?.plugins, enabledPlugins, 'project')
+  ]
+  const claudeNativePlugins = createClaudeNativePluginAssets(enabledPlugins)
+  assets.push(...hookPlugins, ...claudeNativePlugins, ...openCodeOverlayAssets)
+
+  return {
+    cwd: params.cwd,
+    assets,
+    rules,
+    specs,
+    entities,
+    skills,
+    mcpServers: Object.fromEntries(mcpServers.entries()),
+    hookPlugins,
+    enabledPlugins,
+    extraKnownMarketplaces,
+    defaultIncludeMcpServers: uniqueValues([
+      ...(config?.defaultIncludeMcpServers ?? []),
+      ...(userConfig?.defaultIncludeMcpServers ?? [])
+    ]),
+    defaultExcludeMcpServers: uniqueValues([
+      ...(config?.defaultExcludeMcpServers ?? []),
+      ...(userConfig?.defaultExcludeMcpServers ?? [])
+    ])
+  }
+}

package/src/document-assets.ts

@@ -0,0 +1,191 @@
+import { basename, dirname } from 'node:path'
+
+import type {
+  RuleReference,
+  SkillSelection,
+  WorkspaceAsset,
+  WorkspaceAssetAdapter,
+  WorkspaceAssetBundle,
+  WorkspaceAssetKind,
+  WorkspaceSkillSelection
+} from '@vibe-forge/types'
+import { normalizePath, resolveDocumentName, resolveRelativePath, resolveSpecIdentifier } from '@vibe-forge/utils'
+import { glob } from 'fast-glob'
+
+import { assetOriginPriority, isPluginEnabled, resolvePluginIdFromPath, toAssetScope } from './helpers'
+import type { WorkspaceDocumentAsset, WorkspaceDocumentPayload } from './internal-types'
+
+const isLocalRuleReference = (
+  rule: RuleReference
+): rule is Extract<RuleReference, { path: string }> => (
+  rule != null &&
+  typeof rule === 'object' &&
+  'path' in rule &&
+  typeof rule.path === 'string'
+)
+
+export const createDocumentAsset = <
+  TKind extends Extract<WorkspaceAssetKind, 'rule' | 'spec' | 'entity' | 'skill'>,
+  TDefinition,
+>(
+  params: {
+    cwd: string
+    kind: TKind
+    definition: TDefinition & { path: string }
+    targets?: WorkspaceAssetAdapter[]
+  }
+): Extract<WorkspaceAsset, { kind: TKind }> => {
+  const pluginId = resolvePluginIdFromPath(params.cwd, params.definition.path)
+  const origin: WorkspaceAsset['origin'] = pluginId == null ? 'project' : 'plugin'
+  return {
+    id: `${params.kind}:${resolveRelativePath(params.cwd, params.definition.path)}`,
+    kind: params.kind,
+    pluginId,
+    origin,
+    scope: toAssetScope(origin),
+    enabled: true,
+    targets: params.targets ?? ['claude-code', 'codex', 'opencode'],
+    payload: {
+      definition: params.definition as any,
+      sourcePath: params.definition.path
+    }
+  } as Extract<WorkspaceAsset, { kind: TKind }>
+}
+
+export const dedupeDocumentAssets = <
+  TAsset extends Extract<WorkspaceAsset, { kind: 'rule' | 'spec' | 'entity' | 'skill' }>,
+>(
+  assets: TAsset[],
+  enabledPlugins: Record<string, boolean>
+) => assets.filter((asset) => isPluginEnabled(enabledPlugins, asset.pluginId))
+
+const compareDocumentAssetPriority = (
+  left: Extract<WorkspaceAsset, { kind: 'rule' | 'spec' | 'entity' | 'skill' }>,
+  right: Extract<WorkspaceAsset, { kind: 'rule' | 'spec' | 'entity' | 'skill' }>
+) => {
+  const originDiff = assetOriginPriority[left.origin] - assetOriginPriority[right.origin]
+  if (originDiff !== 0) return originDiff
+  return left.payload.definition.path.localeCompare(right.payload.definition.path)
+}
+
+export const dedupeDocumentAssetsByIdentifier = <
+  TAsset extends Extract<WorkspaceAsset, { kind: 'rule' | 'spec' | 'entity' | 'skill' }>,
+>(
+  assets: TAsset[],
+  resolveIdentifier: (asset: TAsset) => string
+) => {
+  const selected = new Map<string, TAsset>()
+
+  for (const asset of [...assets].sort(compareDocumentAssetPriority)) {
+    const identifier = resolveIdentifier(asset)
+    if (!selected.has(identifier)) selected.set(identifier, asset)
+  }
+
+  return Array.from(selected.values()).sort(compareDocumentAssetPriority)
+}
+
+export const resolveRuleIdentifier = (
+  path: string,
+  explicitName?: string
+) => resolveDocumentName(path, explicitName)
+
+export const resolveSkillIdentifier = (
+  path: string,
+  explicitName?: string
+) => resolveDocumentName(path, explicitName, ['skill.md'])
+
+export const pickSpecAsset = (
+  bundle: WorkspaceAssetBundle,
+  name: string
+): Extract<WorkspaceAsset, { kind: 'spec' }> | undefined => {
+  const assets = bundle.specs.filter((asset) => {
+    const definition = asset.payload.definition
+    return resolveSpecIdentifier(definition.path, definition.attributes.name) === name
+  })
+  return assets.find(asset => asset.origin === 'project') ?? assets[0]
+}
+
+export const pickEntityAsset = (
+  bundle: WorkspaceAssetBundle,
+  name: string
+): Extract<WorkspaceAsset, { kind: 'entity' }> | undefined => {
+  const assets = bundle.entities.filter((asset) => {
+    const definition = asset.payload.definition
+    const identifier = resolveDocumentName(definition.path, definition.attributes.name, ['readme.md', 'index.json'])
+    return identifier === name
+  })
+  return assets.find(asset => asset.origin === 'project') ?? assets[0]
+}
+
+export const filterSkillAssets = (
+  skills: Array<Extract<WorkspaceAsset, { kind: 'skill' }>>,
+  selection?: WorkspaceSkillSelection
+): Array<Extract<WorkspaceAsset, { kind: 'skill' }>> => {
+  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.payload.definition.path))
+    return (include == null || include.has(name)) && !exclude.has(name)
+  })
+}
+
+export const dedupeSkillAssets = (
+  skills: Array<Extract<WorkspaceAsset, { kind: 'skill' }>>
+): Array<Extract<WorkspaceAsset, { kind: 'skill' }>> => {
+  const seen = new Set<string>()
+  return skills.filter((skill) => {
+    if (seen.has(skill.payload.definition.path)) return false
+    seen.add(skill.payload.definition.path)
+    return true
+  })
+}
+
+export const resolveRulePatterns = (rules: RuleReference[]) => (
+  rules.flatMap((rule) => {
+    if (typeof rule === 'string') return [rule]
+    if (isLocalRuleReference(rule)) return [rule.path]
+    return []
+  })
+)
+
+export const resolveIncludedSkillNames = (selection: string[] | SkillSelection) => (
+  Array.isArray(selection)
+    ? selection
+    : selection.type === 'include'
+    ? selection.list
+    : []
+)
+
+export const resolveExcludedSkillNames = (selection: string[] | SkillSelection) => (
+  Array.isArray(selection)
+    ? []
+    : selection.type === 'exclude'
+    ? selection.list
+    : []
+)
+
+export const resolveSelectedRuleAssets = async (
+  bundle: WorkspaceAssetBundle,
+  patterns: string[]
+): Promise<Array<Extract<WorkspaceAsset, { kind: 'rule' }>>> => {
+  const matchedPaths = new Set(
+    (await glob(patterns, { cwd: bundle.cwd, absolute: true }))
+      .map(normalizePath)
+  )
+  return bundle.rules.filter((asset) => matchedPaths.has(normalizePath(asset.payload.definition.path)))
+}
+
+export const toDocumentDefinitions = <TDefinition>(
+  assets: Array<WorkspaceDocumentAsset<TDefinition>>
+) => assets.map(asset => asset.payload.definition)
+
+export const toPromptAssetIds = (assets: Array<{ id: string }>) => (
+  Array.from(new Set(assets.map(asset => asset.id)))
+)
+
+export type { WorkspaceDocumentAsset, WorkspaceDocumentPayload }

package/src/helpers.ts

@@ -0,0 +1,35 @@
+import type { WorkspaceAsset } from '@vibe-forge/types'
+import { resolveRelativePath } from '@vibe-forge/utils'
+
+export const resolvePluginIdFromPath = (cwd: string, path: string) => {
+  const relativePath = resolveRelativePath(cwd, path)
+  const match = relativePath.match(/^\.ai\/plugins\/([^/]+)\//)
+  return match?.[1]
+}
+
+export const isPluginEnabled = (
+  enabledPlugins: Record<string, boolean>,
+  pluginId?: string
+) => pluginId == null || enabledPlugins[pluginId] !== false
+
+export const mergeRecord = <T>(left?: Record<string, T>, right?: Record<string, T>) => ({
+  ...(left ?? {}),
+  ...(right ?? {})
+})
+
+export const uniqueValues = (values: string[]) => Array.from(new Set(values.filter(Boolean)))
+
+export const assetOriginPriority: Record<WorkspaceAsset['origin'], number> = {
+  project: 0,
+  plugin: 1,
+  config: 2,
+  fallback: 3
+}
+
+export const toAssetScope = (origin: WorkspaceAsset['origin']): WorkspaceAsset['scope'] => (
+  origin === 'config'
+    ? 'project'
+    : origin === 'fallback'
+    ? 'adapter'
+    : 'workspace'
+)