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

package/src/bundle.ts

@@ -1,178 +1,29 @@
-import process from 'node:process'
+import type { Config, PluginConfig, WorkspaceAssetBundle } from '@vibe-forge/types'
 
-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)
-  })
-}
+import { collectWorkspaceAssets } from './bundle-internal'
 
 export async function resolveWorkspaceAssetBundle(params: {
   cwd: string
   configs?: [Config?, Config?]
+  plugins?: PluginConfig
+  overlaySource?: string
   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)
+  const collected = await collectWorkspaceAssets(params)
 
   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 ?? [])
-    ])
+    pluginConfigs: collected.pluginConfigs,
+    pluginInstances: collected.pluginInstances,
+    assets: collected.assets,
+    rules: collected.rules,
+    specs: collected.specs,
+    entities: collected.entities,
+    skills: collected.skills,
+    mcpServers: collected.mcpServers,
+    hookPlugins: collected.hookPlugins,
+    opencodeOverlayAssets: collected.opencodeOverlayAssets,
+    defaultIncludeMcpServers: collected.defaultIncludeMcpServers,
+    defaultExcludeMcpServers: collected.defaultExcludeMcpServers
   }
 }

package/src/internal-types.ts

@@ -1,41 +1,3 @@
 import type { WorkspaceAsset } from '@vibe-forge/types'
 
-export interface WorkspaceDocumentPayload<TDefinition> {
-  definition: TDefinition
-  sourcePath: string
-}
-
-export interface WorkspaceOverlayPayload {
-  sourcePath: string
-  entryName: string
-  targetSubpath: string
-}
-
-export type WorkspaceOpenCodeOverlayAsset =
-  | (
-    & Extract<WorkspaceAsset, { kind: 'nativePlugin' }>
-    & { payload: WorkspaceOverlayPayload }
-  )
-  | Extract<WorkspaceAsset, { kind: 'agent' | 'command' | 'mode' }>
-
-export type WorkspaceDocumentAsset<TDefinition> =
-  & Extract<
-    WorkspaceAsset,
-    { kind: 'rule' | 'spec' | 'entity' | 'skill' }
-  >
-  & {
-    payload: WorkspaceDocumentPayload<TDefinition & { path: string }>
-  }
-
-export const isOverlayPayload = (payload: unknown): payload is WorkspaceOverlayPayload => (
-  payload != null &&
-  typeof payload === 'object' &&
-  typeof (payload as WorkspaceOverlayPayload).sourcePath === 'string' &&
-  typeof (payload as WorkspaceOverlayPayload).entryName === 'string' &&
-  typeof (payload as WorkspaceOverlayPayload).targetSubpath === 'string'
-)
-
-export const isOpenCodeOverlayAsset = (asset: WorkspaceAsset): asset is WorkspaceOpenCodeOverlayAsset => (
-  (asset.kind === 'nativePlugin' || asset.kind === 'agent' || asset.kind === 'command' || asset.kind === 'mode') &&
-  isOverlayPayload(asset.payload)
-)
+export const isOpenCodeOverlayAsset = (asset: WorkspaceAsset) => asset.kind === 'nativePlugin'

package/src/prompt-builders.ts

@@ -0,0 +1,184 @@
+import {
+  isAlwaysRule,
+  resolveDefinitionName,
+  resolveDocumentDescription,
+  resolveSpecIdentifier
+} from '@vibe-forge/definition-core'
+import type { Definition, Entity, Rule, Skill, Spec } from '@vibe-forge/types'
+import { resolvePromptPath } from '@vibe-forge/utils'
+
+const toMarkdownBlockquote = (content: string) => (
+  content
+    .trim()
+    .split('\n')
+    .map(line => line === '' ? '>' : `> ${line}`)
+    .join('\n')
+)
+
+const buildOptionalRuleGuidance = (cwd: string, rule: Definition<Rule>) => {
+  const name = resolveDefinitionName(rule)
+  const desc = resolveDocumentDescription(rule.body, rule.attributes.description, name)
+  return [
+    `Use when: ${desc}`,
+    `Rule file path: ${resolvePromptPath(cwd, rule.path)}`,
+    'Only read this rule file when the task matches the scenario above.'
+  ].join('\n')
+}
+
+const buildSkillSummary = (
+  cwd: string,
+  skill: Definition<Skill>,
+  guidance: string
+) => {
+  const name = resolveDefinitionName(skill, ['skill.md'])
+  const desc = resolveDocumentDescription(skill.body, skill.attributes.description, name)
+  return toMarkdownBlockquote(
+    [
+      `Skill description: ${desc}`,
+      `Skill file path: ${resolvePromptPath(cwd, skill.path)}`,
+      guidance
+    ].join('\n')
+  )
+}
+
+const renderSkillModule = (
+  cwd: string,
+  skill: Definition<Skill>,
+  options: {
+    guidance: string
+    includeContent?: boolean
+  }
+) => {
+  const parts = [
+    `# ${resolveDefinitionName(skill, ['skill.md'])}`,
+    '',
+    buildSkillSummary(cwd, skill, options.guidance)
+  ]
+
+  if (options.includeContent) {
+    parts.push('', '<skill-content>', skill.body.trim(), '</skill-content>')
+  }
+
+  return parts.join('\n')
+}
+
+export const generateRulesPrompt = (cwd: string, rules: Definition<Rule>[]) => {
+  const rulesPrompt = rules
+    .map((rule) => {
+      const content = isAlwaysRule(rule.attributes) && rule.body.trim()
+        ? rule.body.trim()
+        : buildOptionalRuleGuidance(cwd, rule)
+      return `# ${resolveDefinitionName(rule)}\n\n${toMarkdownBlockquote(content)}`
+    })
+    .filter(Boolean)
+    .join('\n\n')
+
+  return (
+    '<system-prompt>\n' +
+    'The project system rules are:\n' +
+    `${rulesPrompt}\n` +
+    '</system-prompt>\n'
+  )
+}
+
+export const generateSkillsPrompt = (cwd: string, skills: Definition<Skill>[]) => {
+  const modules = skills
+    .map(skill =>
+      renderSkillModule(cwd, skill, {
+        guidance:
+          'Resolve relative paths in the resource content relative to the directory containing this skill file.',
+        includeContent: true
+      })
+    )
+    .filter(Boolean)
+    .join('\n\n')
+
+  if (modules === '') return ''
+
+  return `<system-prompt>\nThe following skill modules are loaded for the project:\n${modules}\n</system-prompt>\n`
+}
+
+export const generateSkillsRoutePrompt = (cwd: string, skills: Definition<Skill>[]) => {
+  const modules = skills
+    .filter(({ attributes: { always } }) => always !== false)
+    .map(skill =>
+      renderSkillModule(cwd, skill, {
+        guidance:
+          'Do not preload the body by default; read the corresponding skill file only when the task clearly requires it.'
+      })
+    )
+    .filter(Boolean)
+    .join('\n\n')
+
+  if (modules === '') return ''
+
+  return `<skills>\n${modules}\n</skills>\n`
+}
+
+export const generateSpecRoutePrompt = (
+  specsDocuments: Definition<Spec>[],
+  options?: { active?: boolean }
+) => {
+  const specsRouteStr = specsDocuments
+    .filter(({ attributes }) => attributes.always !== false)
+    .map((definition) => {
+      const name = resolveDefinitionName(definition, ['index.md'])
+      const desc = resolveDocumentDescription(definition.body, definition.attributes.description, name)
+      const identifier = definition.resolvedName?.trim() ||
+        resolveSpecIdentifier(definition.path, definition.attributes.name)
+      const params = definition.attributes.params ?? []
+      const paramsPrompt = params.length > 0
+        ? params
+          .map(({ name, description }) => `    - ${name}: ${description ?? 'None'}\n`)
+          .join('')
+        : '    - None\n'
+
+      return (
+        `- Workflow name: ${name}\n` +
+        `  - Description: ${desc}\n` +
+        `  - Identifier: ${identifier}\n` +
+        '  - Parameters:\n' +
+        `${paramsPrompt}`
+      )
+    })
+    .join('\n')
+
+  const activeIdentityPrompt = options?.active
+    ? (
+      'You are a professional project execution manager who can skillfully direct other entities to work toward your goal. Expectations:\n' +
+      '\n' +
+      '- Never complete code development work alone\n' +
+      '- You must coordinate other developers to complete tasks\n' +
+      '- You must keep them aligned with the goal and verify that their completion reports meet the requirements\n' +
+      '\n'
+    )
+    : ''
+
+  return (
+    `<system-prompt>\n${activeIdentityPrompt}Choose the appropriate workflow based on the user's needs and the actual development goal, and use the workflow identifier to locate and load the corresponding definition.\n` +
+    '- Pass the identifier based on the actual need. This is not a path; use the standard workflow loading capability to resolve it.\n' +
+    '- Decide how to pass parameters based on their descriptions and actual usage scenarios.\n' +
+    'The project includes the following workflows:\n' +
+    `${specsRouteStr}\n` +
+    '</system-prompt>\n'
+  )
+}
+
+export const generateEntitiesRoutePrompt = (entities: Definition<Entity>[]) => {
+  return (
+    '<system-prompt>\n' +
+    'The project includes the following entities:\n' +
+    `${
+      entities
+        .filter(({ attributes }) => attributes.always !== false)
+        .map((definition) => {
+          const name = resolveDefinitionName(definition, ['readme.md', 'index.json'])
+          const desc = resolveDocumentDescription(definition.body, definition.attributes.description, name)
+          return `  - ${name}: ${desc}\n`
+        })
+        .join('')
+    }\n` +
+    'When solving user problems, you may specify entities through `vibe-forge.StartTasks` as needed and have them coordinate multiple entity types to complete the work; use `GetTaskInfo` and `wait` to track progress.\n' +
+    '</system-prompt>\n'
+  )
+}