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

package/src/document-assets.ts

@@ -1,191 +0,0 @@
-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

@@ -1,35 +0,0 @@
-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'
-)

package/src/plugin-assets.ts

@@ -1,175 +0,0 @@
-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' }>))
-}