@vibe-forge/workspace-assets 3.2.2-alpha.1 → 3.2.2-alpha.3

package/__tests__/bundle.spec.ts

@@ -7,7 +7,8 @@ import { afterEach, describe, expect, it, vi } from 'vitest'
 const skillsCliMocks = vi.hoisted(() => ({
   findSkillsCli: vi.fn(),
   installSkillsCliRefToTemp: vi.fn(),
-  installSkillsCliSkillToTemp: vi.fn()
+  installSkillsCliSkillToTemp: vi.fn(),
+  installSkillsCliSourceToTemp: vi.fn()
 }))
 
 vi.mock('@vibe-forge/utils/skills-cli', async () => {
@@ -16,7 +17,8 @@ vi.mock('@vibe-forge/utils/skills-cli', async () => {
     ...actual,
     findSkillsCli: skillsCliMocks.findSkillsCli,
     installSkillsCliRefToTemp: skillsCliMocks.installSkillsCliRefToTemp,
-    installSkillsCliSkillToTemp: skillsCliMocks.installSkillsCliSkillToTemp
+    installSkillsCliSkillToTemp: skillsCliMocks.installSkillsCliSkillToTemp,
+    installSkillsCliSourceToTemp: skillsCliMocks.installSkillsCliSourceToTemp
   }
 })
 
@@ -410,6 +412,72 @@ describe('resolveWorkspaceAssetBundle', () => {
     expect(warn).toHaveBeenCalledWith(expect.stringContaining('Declared skills are not installed: internal-review'))
   })
 
+  it('warns when a configured skill source collection is missing', async () => {
+    const workspace = await createWorkspace()
+    const warn = vi.spyOn(console, 'warn').mockImplementation(() => undefined)
+
+    const bundle = await resolveWorkspaceAssetBundle({
+      cwd: workspace,
+      configs: [{
+        skills: [
+          {
+            include: ['*'],
+            source: 'example-source/default/public'
+          }
+        ]
+      }, undefined],
+      warnMissingConfiguredSkills: true,
+      useDefaultVibeForgeMcpServer: false
+    })
+
+    expect(bundle.skills.map(asset => asset.name)).toEqual([])
+    expect(skillsCliMocks.installSkillsCliSourceToTemp).not.toHaveBeenCalled()
+    expect(warn).toHaveBeenCalledWith(
+      expect.stringContaining('Declared skill sources are not installed: example-source/default/public')
+    )
+  })
+
+  it('does not warn for installed configured skill source collections', async () => {
+    const workspace = await createWorkspace()
+    const warn = vi.spyOn(console, 'warn').mockImplementation(() => undefined)
+
+    await writeDocument(
+      join(workspace, '.ai/skills/source-review/SKILL.md'),
+      '---\nname: source-review\ndescription: Existing skill\n---\nExisting content.\n'
+    )
+    await writeDocument(
+      join(workspace, '.ai/skills.lock.yaml'),
+      [
+        'version: 1',
+        'skills:',
+        '  source-review:',
+        '    name: source-review',
+        '    requested: true',
+        '    installPath: .ai/skills/source-review',
+        '    source: example-source/default/public',
+        '    hash: sha256:test',
+        '    installedAt: "2026-05-14T00:00:00.000Z"'
+      ].join('\n')
+    )
+
+    const bundle = await resolveWorkspaceAssetBundle({
+      cwd: workspace,
+      configs: [{
+        skills: [
+          {
+            include: ['*'],
+            source: 'example-source/default/public'
+          }
+        ]
+      }, undefined],
+      warnMissingConfiguredSkills: true,
+      useDefaultVibeForgeMcpServer: false
+    })
+
+    expect(bundle.skills.map(asset => asset.name)).toContain('source-review')
+    expect(warn).not.toHaveBeenCalled()
+  })
+
   it('loads installed configured skills without attempting runtime updates', async () => {
     const workspace = await createWorkspace()
     await writeDocument(

package/__tests__/prompt-selection.spec.ts

@@ -2,11 +2,53 @@ import { join } from 'node:path'
 
 import { describe, expect, it } from 'vitest'
 
+import { writeProjectSkillsLockfile } from '@vibe-forge/utils'
+
 import { resolvePromptAssetSelection, resolveWorkspaceAssetBundle } from '#~/index.js'
 
 import { createWorkspace, installPluginPackage, writeDocument } from './test-helpers'
 
 describe('resolvePromptAssetSelection', () => {
+  it('loads nested project skills through the project skills lockfile', async () => {
+    const workspace = await createWorkspace()
+    const skillPath = join(workspace, '.ai/skills/.extends/base-skills/larksuite-cli/lark-doc/SKILL.md')
+    await writeDocument(
+      skillPath,
+      [
+        '---',
+        'name: lark-doc',
+        'description: Lark docs',
+        '---',
+        'Read docs.'
+      ].join('\n')
+    )
+    await writeProjectSkillsLockfile(workspace, {
+      version: 1,
+      skills: {
+        'lark-doc': {
+          hash: 'sha256:test',
+          installedAt: '2026-01-01T00:00:00.000Z',
+          installPath: '.ai/skills/.extends/base-skills/larksuite-cli/lark-doc',
+          name: 'lark-doc',
+          requested: true,
+          source: 'larksuite/cli'
+        }
+      }
+    })
+
+    const bundle = await resolveWorkspaceAssetBundle({
+      cwd: workspace,
+      useDefaultVibeForgeMcpServer: false
+    })
+
+    expect(bundle.skills).toEqual(expect.arrayContaining([
+      expect.objectContaining({
+        name: 'lark-doc',
+        sourcePath: skillPath
+      })
+    ]))
+  })
+
   it('embeds only alwaysApply rules and keeps optional rules as summaries', async () => {
     const workspace = await createWorkspace()
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vibe-forge/workspace-assets",
-  "version": "3.2.2-alpha.1",
+  "version": "3.2.2-alpha.3",
   "description": "Workspace asset resolution and adapter asset planning for Vibe Forge",
   "imports": {
     "#~/*.js": {
@@ -29,10 +29,10 @@
     "fast-glob": "^3.3.3",
     "front-matter": "^4.0.2",
     "js-yaml": "^4.1.1",
-    "@vibe-forge/config": "3.2.3-alpha.1",
-    "@vibe-forge/utils": "3.2.3-alpha.1",
+    "@vibe-forge/config": "3.2.3-alpha.3",
     "@vibe-forge/types": "3.2.3-alpha.1",
-    "@vibe-forge/definition-core": "3.2.0"
+    "@vibe-forge/definition-core": "3.2.0",
+    "@vibe-forge/utils": "3.2.3-alpha.3"
   },
   "devDependencies": {
     "@types/js-yaml": "^4.0.9"

package/src/bundle-internal.ts

@@ -377,9 +377,18 @@ const createOpenCodeOverlayAsset = <TKind extends OpenCodeOverlayKind>(params: {
 const scanWorkspaceDocuments = async (cwd: string) => {
   const aiBaseDir = resolveProjectAiBaseDir(cwd, process.env)
   const entitiesDir = resolveProjectAiEntitiesDir(cwd, process.env)
-  const [rulePaths, skillPaths, specPaths, entityDocPaths, entityJsonPaths, mcpPaths] = await Promise.all([
+  const [
+    rulePaths,
+    directSkillPaths,
+    lockedSkillPaths,
+    specPaths,
+    entityDocPaths,
+    entityJsonPaths,
+    mcpPaths
+  ] = await Promise.all([
     glob(['rules/*.md'], { cwd: aiBaseDir, absolute: true }),
     glob(['skills/*/SKILL.md'], { cwd: aiBaseDir, absolute: true }),
+    scanProjectSkillLockfileDocuments(cwd),
     glob(['specs/*.md', 'specs/*/index.md'], { cwd: aiBaseDir, absolute: true }),
     glob(['*.md', '*/README.md'], { cwd: entitiesDir, absolute: true }),
     glob(['*/index.json'], { cwd: entitiesDir, absolute: true }),
@@ -388,7 +397,7 @@ const scanWorkspaceDocuments = async (cwd: string) => {
 
   return {
     rulePaths,
-    skillPaths,
+    skillPaths: Array.from(new Set([...directSkillPaths, ...lockedSkillPaths])),
     specPaths,
     entityDocPaths,
     entityJsonPaths,
@@ -451,6 +460,19 @@ const pathExists = async (path: string) => {
   }
 }
 
+const scanProjectSkillLockfileDocuments = async (cwd: string) => {
+  const lockfile = await readProjectSkillsLockfile(cwd)
+  const skillPaths: string[] = []
+  for (const entry of Object.values(lockfile.skills ?? {})) {
+    const skillPath = resolve(cwd, entry.installPath, 'SKILL.md')
+    if (await pathExists(skillPath)) {
+      skillPaths.push(skillPath)
+    }
+  }
+
+  return skillPaths
+}
+
 const scanPluginDependencySkillDocuments = async (
   cwd: string,
   instances: ResolvedPluginInstance[]

package/src/configured-skills.ts

@@ -1,23 +1,68 @@
 import { access } from 'node:fs/promises'
+import { isAbsolute, join, resolve as resolvePath } from 'node:path'
 import process from 'node:process'
 
-import type { Config, ConfiguredSkillInstallConfig } from '@vibe-forge/types'
+import type {
+  Config,
+  ConfiguredSkillCollectionConfig,
+  ConfiguredSkillIncludeConfig,
+  ConfiguredSkillInstallConfig
+} from '@vibe-forge/types'
 import {
+  isConfiguredSkillCollectionInstall,
+  isWildcardSkillInclude,
   normalizeProjectSkillInstall,
+  readProjectSkillsLockfile,
   resolveConfiguredSkillInstalls as resolveDeclaredConfiguredSkillInstalls,
-  resolveProjectAiPath
+  resolveProjectAiPath,
+  toSkillSlug
 } from '@vibe-forge/utils'
-import type { NormalizedProjectSkillInstall } from '@vibe-forge/utils'
+import type { NormalizedProjectSkillInstall, ProjectSkillLockEntry } from '@vibe-forge/utils'
+
+interface NormalizedConfiguredSkillCollection {
+  include?: ConfiguredSkillCollectionConfig['include']
+  registry?: string
+  source: string
+  version?: string
+}
+
+interface MissingConfiguredProjectSkillCollection extends NormalizedConfiguredSkillCollection {
+  missingTargets?: string[]
+}
+
+const normalizeNonEmptyString = (value: unknown) => (
+  typeof value === 'string' && value.trim() !== '' ? value.trim() : undefined
+)
+
+const resolveConfiguredProjectSkillDeclarations = (configs: [Config?, Config?]) => [
+  ...resolveDeclaredConfiguredSkillInstalls(configs[0]?.skills),
+  ...resolveDeclaredConfiguredSkillInstalls(configs[1]?.skills)
+]
 
 export const resolveConfiguredProjectSkillInstalls = (configs: [Config?, Config?]) => (
-  [
-    ...resolveDeclaredConfiguredSkillInstalls(configs[0]?.skills),
-    ...resolveDeclaredConfiguredSkillInstalls(configs[1]?.skills)
-  ]
+  resolveConfiguredProjectSkillDeclarations(configs)
     .map((item) => normalizeProjectSkillInstall(item as string | ConfiguredSkillInstallConfig))
     .filter((item): item is NormalizedProjectSkillInstall => item != null)
 )
 
+export const resolveConfiguredProjectSkillCollections = (configs: [Config?, Config?]) => (
+  resolveConfiguredProjectSkillDeclarations(configs)
+    .map((item) => {
+      if (!isConfiguredSkillCollectionInstall(item)) return undefined
+      const source = normalizeNonEmptyString(item.source)
+      if (source == null) return undefined
+      const registry = normalizeNonEmptyString(item.registry)
+      const version = normalizeNonEmptyString(item.version)
+      return {
+        ...(item.include == null ? {} : { include: item.include }),
+        ...(registry == null ? {} : { registry }),
+        source,
+        ...(version == null ? {} : { version })
+      }
+    })
+    .filter((item): item is NormalizedConfiguredSkillCollection => item != null)
+)
+
 const pathExists = async (targetPath: string) => {
   try {
     await access(targetPath)
@@ -27,6 +72,77 @@ const pathExists = async (targetPath: string) => {
   }
 }
 
+const isWildcardCollection = (collection: NormalizedConfiguredSkillCollection) => (
+  collection.include == null ||
+  collection.include.length === 0 ||
+  collection.include.some(isWildcardSkillInclude)
+)
+
+const normalizeCollectionTarget = (
+  include: ConfiguredSkillIncludeConfig
+) => {
+  if (isWildcardSkillInclude(include)) return undefined
+
+  const name = normalizeNonEmptyString(typeof include === 'string' ? include : include.name)
+  if (name == null) return undefined
+  const rename = typeof include === 'string' ? undefined : normalizeNonEmptyString(include.rename)
+  const targetName = rename ?? name
+  const targetDirName = toSkillSlug(targetName)
+  if (targetDirName === '') return undefined
+
+  return {
+    targetDirName,
+    targetName
+  }
+}
+
+const lockEntryMatchesCollection = (
+  entry: ProjectSkillLockEntry,
+  collection: NormalizedConfiguredSkillCollection
+) => (
+  entry.source === collection.source &&
+  (collection.registry == null || entry.registry === collection.registry) &&
+  (collection.version == null || entry.version === collection.version)
+)
+
+const resolveLockEntrySkillPath = (workspaceFolder: string, entry: ProjectSkillLockEntry) => {
+  const installDir = isAbsolute(entry.installPath)
+    ? entry.installPath
+    : resolvePath(workspaceFolder, entry.installPath)
+  return join(installDir, 'SKILL.md')
+}
+
+const hasInstalledCollectionLockEntry = async (params: {
+  collection: NormalizedConfiguredSkillCollection
+  entries: Record<string, ProjectSkillLockEntry>
+  workspaceFolder: string
+}) => {
+  for (const entry of Object.values(params.entries)) {
+    if (!lockEntryMatchesCollection(entry, params.collection)) continue
+    if (await pathExists(resolveLockEntrySkillPath(params.workspaceFolder, entry))) return true
+  }
+
+  return false
+}
+
+const hasInstalledSkillTarget = async (params: {
+  entries: Record<string, ProjectSkillLockEntry>
+  targetDirName: string
+  workspaceFolder: string
+}) => {
+  const entry = params.entries[params.targetDirName]
+  if (entry != null && await pathExists(resolveLockEntrySkillPath(params.workspaceFolder, entry))) return true
+
+  const skillPath = resolveProjectAiPath(
+    params.workspaceFolder,
+    process.env,
+    'skills',
+    params.targetDirName,
+    'SKILL.md'
+  )
+  return pathExists(skillPath)
+}
+
 export const ensureUniqueConfiguredSkillTargets = (skills: NormalizedProjectSkillInstall[]) => {
   const seen = new Map<string, string>()
 
@@ -52,32 +168,117 @@ export const findMissingConfiguredProjectSkills = async (params: {
 
   ensureUniqueConfiguredSkillTargets(installs)
 
+  const lockfile = await readProjectSkillsLockfile(params.workspaceFolder)
   const missing: NormalizedProjectSkillInstall[] = []
   for (const skill of installs) {
-    const skillPath = resolveProjectAiPath(
-      params.workspaceFolder,
-      process.env,
-      'skills',
-      skill.targetDirName,
-      'SKILL.md'
-    )
-    if (!await pathExists(skillPath)) missing.push(skill)
+    if (
+      !await hasInstalledSkillTarget({
+        entries: lockfile.skills ?? {},
+        targetDirName: skill.targetDirName,
+        workspaceFolder: params.workspaceFolder
+      })
+    ) {
+      missing.push(skill)
+    }
+  }
+
+  return missing
+}
+
+export const findMissingConfiguredProjectSkillCollections = async (params: {
+  configs: [Config?, Config?]
+  workspaceFolder: string
+}) => {
+  const collections = resolveConfiguredProjectSkillCollections(params.configs)
+  if (collections.length === 0) return []
+
+  const lockfile = await readProjectSkillsLockfile(params.workspaceFolder)
+  const missing: MissingConfiguredProjectSkillCollection[] = []
+  const seen = new Set<string>()
+
+  const addMissing = (collection: MissingConfiguredProjectSkillCollection) => {
+    const key = [
+      collection.source,
+      collection.registry ?? '',
+      collection.version ?? '',
+      collection.missingTargets?.join('|') ?? '*'
+    ].join('\0')
+    if (seen.has(key)) return
+    seen.add(key)
+    missing.push(collection)
+  }
+
+  for (const collection of collections) {
+    if (isWildcardCollection(collection)) {
+      if (
+        !await hasInstalledCollectionLockEntry({
+          collection,
+          entries: lockfile.skills ?? {},
+          workspaceFolder: params.workspaceFolder
+        })
+      ) {
+        addMissing(collection)
+      }
+      continue
+    }
+
+    const missingTargets: string[] = []
+    for (const include of collection.include ?? []) {
+      const target = normalizeCollectionTarget(include)
+      if (target == null) continue
+      if (
+        !await hasInstalledSkillTarget({
+          entries: lockfile.skills ?? {},
+          targetDirName: target.targetDirName,
+          workspaceFolder: params.workspaceFolder
+        })
+      ) {
+        missingTargets.push(target.targetName)
+      }
+    }
+
+    if (missingTargets.length > 0) {
+      addMissing({
+        ...collection,
+        missingTargets
+      })
+    }
   }
 
   return missing
 }
 
+const formatMissingCollectionLabel = (collection: MissingConfiguredProjectSkillCollection) => {
+  const sourceLabel = collection.version == null
+    ? collection.source
+    : `${collection.source}@${collection.version}`
+  if (collection.missingTargets == null || collection.missingTargets.length === 0) return sourceLabel
+  return `${sourceLabel} (${collection.missingTargets.join(', ')})`
+}
+
 export const warnMissingConfiguredProjectSkills = async (params: {
   configs: [Config?, Config?]
   workspaceFolder: string
 }) => {
   const missing = await findMissingConfiguredProjectSkills(params)
-  if (missing.length === 0) return []
+  const missingCollections = await findMissingConfiguredProjectSkillCollections(params)
+  if (missing.length === 0 && missingCollections.length === 0) return []
+
+  if (missing.length > 0) {
+    const names = missing.map(skill => skill.targetName).join(', ')
+    console.warn(
+      `[vibe-forge] Declared skills are not installed: ${names}. ` +
+        'Run `vf skills install` to install all declared skills, or `vf skills install <name>` for one skill.'
+    )
+  }
+
+  if (missingCollections.length > 0) {
+    const sources = missingCollections.map(formatMissingCollectionLabel).join(', ')
+    console.warn(
+      `[vibe-forge] Declared skill sources are not installed: ${sources}. ` +
+        'Run `vf skills install` to install all declared skills.'
+    )
+  }
 
-  const names = missing.map(skill => skill.targetName).join(', ')
-  console.warn(
-    `[vibe-forge] Declared skills are not installed: ${names}. ` +
-      'Run `vf skills install` to install all declared skills, or `vf skills install <name>` for one skill.'
-  )
   return missing
 }