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

package/src/internal-types.ts

@@ -1,3 +1,41 @@
 import type { WorkspaceAsset } from '@vibe-forge/types'
 
-export const isOpenCodeOverlayAsset = (asset: WorkspaceAsset) => asset.kind === 'nativePlugin'
+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)
+)

package/src/plugin-assets.ts

@@ -0,0 +1,175 @@
+import { readFile } from 'node:fs/promises'
+import { basename, extname } from 'node:path'
+
+import type { Config, WorkspaceAsset, WorkspaceAssetAdapter } from '@vibe-forge/types'
+import { resolveRelativePath } from '@vibe-forge/utils'
+import { glob } from 'fast-glob'
+import yaml from 'js-yaml'
+
+import { isPluginEnabled, resolvePluginIdFromPath } from './helpers'
+import type { WorkspaceOpenCodeOverlayAsset } from './internal-types'
+
+const parseStructuredDocument = async (path: string) => {
+  const raw = await readFile(path, 'utf8')
+  const extension = extname(path).toLowerCase()
+  if (extension === '.yaml' || extension === '.yml') {
+    return yaml.load(raw)
+  }
+  return JSON.parse(raw)
+}
+
+export const loadPluginMcpAssets = async (
+  cwd: string,
+  enabledPlugins: Record<string, boolean>
+): Promise<Array<Extract<WorkspaceAsset, { kind: 'mcpServer' }>>> => {
+  const paths = await glob([
+    '.ai/plugins/*/mcp/*.json',
+    '.ai/plugins/*/mcp/*.yaml',
+    '.ai/plugins/*/mcp/*.yml'
+  ], {
+    cwd,
+    absolute: true
+  })
+
+  const entries = await Promise.all(paths.map(async (path) => {
+    const pluginId = resolvePluginIdFromPath(cwd, path)
+    if (!isPluginEnabled(enabledPlugins, pluginId)) return undefined
+
+    const parsed = await parseStructuredDocument(path)
+    if (parsed == null || typeof parsed !== 'object' || Array.isArray(parsed)) return undefined
+
+    const record = parsed as Record<string, unknown>
+    const name = typeof record.name === 'string' && record.name.trim() !== ''
+      ? record.name.trim()
+      : basename(path, extname(path))
+    const { name: _name, ...config } = record
+
+    return {
+      id: `mcpServer:${resolveRelativePath(cwd, path)}`,
+      kind: 'mcpServer',
+      pluginId,
+      origin: 'plugin',
+      scope: 'workspace',
+      enabled: true,
+      targets: ['claude-code', 'codex', 'opencode'],
+      payload: {
+        name,
+        config: config as NonNullable<Config['mcpServers']>[string]
+      }
+    } satisfies Extract<WorkspaceAsset, { kind: 'mcpServer' }>
+  }))
+
+  return entries.filter((entry): entry is NonNullable<typeof entry> => entry != null)
+}
+
+export const loadOpenCodeOverlayAssets = async (
+  cwd: string,
+  enabledPlugins: Record<string, boolean>
+): Promise<WorkspaceOpenCodeOverlayAsset[]> => {
+  const paths = await glob([
+    '.ai/plugins/*/opencode/plugins/*',
+    '.ai/plugins/*/opencode/agents/*',
+    '.ai/plugins/*/opencode/commands/*',
+    '.ai/plugins/*/opencode/modes/*'
+  ], {
+    cwd,
+    absolute: true,
+    onlyFiles: false
+  })
+
+  return paths
+    .map((path) => {
+      const relativePath = resolveRelativePath(cwd, path)
+      const match = relativePath.match(/^\.ai\/plugins\/([^/]+)\/opencode\/(plugins|agents|commands|modes)\/([^/]+)$/)
+      if (!match) return undefined
+
+      const [, pluginId, rawFolder, entryName] = match
+      if (!isPluginEnabled(enabledPlugins, pluginId)) return undefined
+
+      const base = {
+        pluginId,
+        origin: 'plugin' as const,
+        scope: 'workspace' as const,
+        enabled: true,
+        targets: ['opencode'] as WorkspaceAssetAdapter[],
+        payload: {
+          sourcePath: path,
+          entryName,
+          targetSubpath: `${rawFolder}/${entryName}`
+        }
+      }
+
+      if (rawFolder === 'plugins') {
+        return {
+          id: `nativePlugin:${relativePath}`,
+          kind: 'nativePlugin',
+          ...base
+        } satisfies Extract<WorkspaceAsset, { kind: 'nativePlugin' }>
+      }
+
+      if (rawFolder === 'agents') {
+        return {
+          id: `agent:${relativePath}`,
+          kind: 'agent',
+          ...base
+        } satisfies Extract<WorkspaceAsset, { kind: 'agent' }>
+      }
+
+      if (rawFolder === 'commands') {
+        return {
+          id: `command:${relativePath}`,
+          kind: 'command',
+          ...base
+        } satisfies Extract<WorkspaceAsset, { kind: 'command' }>
+      }
+
+      return {
+        id: `mode:${relativePath}`,
+        kind: 'mode',
+        ...base
+      } satisfies Extract<WorkspaceAsset, { kind: 'mode' }>
+    })
+    .filter((entry): entry is NonNullable<typeof entry> => entry != null)
+}
+
+export const createHookPluginAssets = (
+  config: Config['plugins'],
+  enabledPlugins: Record<string, boolean>,
+  scope: Extract<WorkspaceAsset['scope'], 'project' | 'user'>
+): Array<Extract<WorkspaceAsset, { kind: 'hookPlugin' }>> => {
+  if (config == null || Array.isArray(config)) return [] as Array<Extract<WorkspaceAsset, { kind: 'hookPlugin' }>>
+
+  return Object.entries(config)
+    .filter((entry) => enabledPlugins[entry[0]] !== false)
+    .map(([pluginId, pluginConfig]) => ({
+      id: `hookPlugin:${scope}:${pluginId}`,
+      kind: 'hookPlugin',
+      pluginId,
+      origin: 'config',
+      scope,
+      enabled: true,
+      targets: ['claude-code', 'codex', 'opencode'],
+      payload: {
+        packageName: pluginId,
+        config: pluginConfig
+      }
+    } satisfies Extract<WorkspaceAsset, { kind: 'hookPlugin' }>))
+}
+
+export const createClaudeNativePluginAssets = (
+  enabledPlugins: Record<string, boolean>
+): Array<Extract<WorkspaceAsset, { kind: 'nativePlugin' }>> => {
+  return Object.entries(enabledPlugins).map(([pluginId, enabled]) => ({
+    id: `nativePlugin:claude-code:${pluginId}`,
+    kind: 'nativePlugin',
+    pluginId,
+    origin: 'config',
+    scope: 'project',
+    enabled,
+    targets: ['claude-code'],
+    payload: {
+      name: pluginId,
+      enabled
+    }
+  } satisfies Extract<WorkspaceAsset, { kind: 'nativePlugin' }>))
+}

package/src/prompt-selection.ts

@@ -0,0 +1,151 @@
+import { basename, dirname } from 'node:path'
+
+import { DefinitionLoader } from '@vibe-forge/definition-loader'
+import type {
+  Filter,
+  PromptAssetResolution,
+  ResolvedPromptAssetOptions,
+  WorkspaceAsset,
+  WorkspaceAssetBundle,
+  WorkspaceSkillSelection
+} from '@vibe-forge/types'
+
+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
+    }
+  }
+): 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 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 })
+    )
+  }
+
+  if (params.type && params.name) {
+    const targetAsset = params.type === 'spec'
+      ? pickSpecAsset(params.bundle, params.name)
+      : pickEntityAsset(params.bundle, params.name)
+
+    if (targetAsset == null) {
+      throw new Error(`Failed to load ${params.type} ${params.name}`)
+    }
+
+    const { definition } = targetAsset.payload
+    const { attributes, body } = definition
+    promptAssetIds.add(targetAsset.id)
+
+    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
+          }
+        }))
+      )
+      for (const asset of matchedRuleAssets) {
+        promptAssetIds.add(asset.id)
+      }
+    }
+
+    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)
+      }
+    }
+
+    targetBody = body
+    targetToolsFilter = attributes.tools
+    targetMcpServersFilter = attributes.mcpServers
+  }
+
+  const targetSkills = toDocumentDefinitions(targetSkillsAssets)
+  const selectedSkillsPrompt = toDocumentDefinitions(
+    selectedSkillAssets.filter(
+      skill => !targetSkillsAssets.some(target => target.payload.definition.path === skill.payload.definition.path)
+    )
+  )
+
+  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) {
+    options.tools = targetToolsFilter
+  }
+  if (targetMcpServersFilter) {
+    options.mcpServers = targetMcpServersFilter
+  }
+
+  options.systemPrompt = systemPromptParts.join('\n\n')
+  options.promptAssetIds = Array.from(promptAssetIds)
+
+  return [
+    {
+      rules,
+      targetSkills,
+      entities,
+      skills,
+      specs,
+      targetBody,
+      promptAssetIds: Array.from(promptAssetIds)
+    },
+    options
+  ]
+}

package/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2025-present Vibe-Forge.ai
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.