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

package/src/prompt-selection.ts

@@ -29,7 +29,7 @@ import {
   resolveEntityInheritance,
   resolveExcludedSkillRefs,
   resolveIncludedSkillRefs,
-  resolveNamedAssets,
+  resolveNamedSkillAssets,
   resolvePluginOverlay,
   resolveRuleSelection,
   resolveSelectedSkillAssetsWithDependencies,
@@ -158,10 +158,10 @@ export async function resolvePromptAssetSelection(params: {
     const includedAssets = skillSelection == null
       ? []
       : includedRefs != null
-      ? (includedRefs.length > 0 ? resolveNamedAssets(effectiveBundle.skills, includedRefs, targetInstancePath) : [])
+      ? (includedRefs.length > 0 ? resolveNamedSkillAssets(effectiveBundle, includedRefs, targetInstancePath) : [])
       : effectiveBundle.skills
     const excludedIds = new Set(
-      resolveNamedAssets(effectiveBundle.skills, excludedRefs, targetInstancePath).map(asset => asset.id)
+      resolveNamedSkillAssets(effectiveBundle, excludedRefs, targetInstancePath).map(asset => asset.id)
     )
 
     const expandedTargetSkills = await expandSkillAssetDependenciesWithRemoteResolution({

package/src/selection-internal.ts

@@ -15,7 +15,7 @@ import type {
   WorkspaceMcpSelection,
   WorkspaceSkillSelection
 } from '@vibe-forge/types'
-import { normalizePath } from '@vibe-forge/utils'
+import { matchesDeclaredSkillSelector, normalizePath } from '@vibe-forge/utils'
 import { mergePluginConfigs, normalizePluginConfig } from '@vibe-forge/utils/plugin-resolver'
 import { glob } from 'fast-glob'
 
@@ -26,6 +26,8 @@ import {
   isRemoteRuleReference,
   parseScopedReference
 } from '@vibe-forge/definition-core'
+import { resolveConfiguredProjectSkillInstalls } from './configured-skills'
+import { PLUGIN_SKILL_DEPENDENCY_RESOLVED_BY } from './plugin-skill-dependencies'
 import { expandSkillAssetDependencies, expandSkillAssetDependenciesWithRemoteResolution } from './skill-dependencies'
 
 type DocumentAssetKind = Extract<WorkspaceAssetKind, 'rule' | 'spec' | 'entity' | 'skill'>
@@ -359,6 +361,10 @@ const mergeEntityDefinitions = (
 
 const uniqueAssetIds = (values: string[]) => toUniqueValues(values, value => value)
 
+const isPluginSkillDependencyAsset = (asset: Extract<WorkspaceAsset, { kind: 'skill' }>) => (
+  asset.resolvedBy === PLUGIN_SKILL_DEPENDENCY_RESOLVED_BY
+)
+
 const formatEntityCycle = (stack: EntityAsset[], asset: EntityAsset) => (
   [...stack.slice(stack.findIndex(item => item.id === asset.id)), asset]
     .map(item => item.displayName)
@@ -511,15 +517,48 @@ export const resolveExcludedSkillRefs = (selection: string[] | SkillSelection |
   return selection.type === 'exclude' ? selection.list : undefined
 }
 
+const createMissingConfiguredSkillMessage = (
+  bundle: WorkspaceAssetBundle,
+  refs: string[] | undefined
+) => {
+  const configs = bundle.configs ?? [undefined, undefined]
+  const declared = resolveConfiguredProjectSkillInstalls(configs)
+
+  for (const ref of refs ?? []) {
+    const match = declared.find(skill => matchesDeclaredSkillSelector(ref, skill))
+    if (match == null) continue
+
+    return `Skill ${ref} is declared in config but is not installed. ` +
+      `Run \`vf skills install ${match.targetName}\` or \`vf skills install\` before selecting it.`
+  }
+
+  return undefined
+}
+
+export const resolveNamedSkillAssets = (
+  bundle: WorkspaceAssetBundle,
+  refs: string[] | undefined,
+  currentInstancePath?: string
+) => {
+  try {
+    return resolveNamedAssets(bundle.skills, refs, currentInstancePath)
+  } catch (error) {
+    const message = createMissingConfiguredSkillMessage(bundle, refs)
+    if (message != null) throw new Error(message)
+    throw error
+  }
+}
+
 export const resolveSelectedSkillAssets = (
   assets: Array<Extract<WorkspaceAsset, { kind: 'skill' }>>,
   selection?: WorkspaceSkillSelection
 ): Array<Extract<WorkspaceAsset, { kind: 'skill' }>> => {
   if (selection == null) return assets
 
+  const rootAssets = assets.filter(asset => !isPluginSkillDependencyAsset(asset))
   const included = selection.include != null && selection.include.length > 0
     ? resolveNamedAssets(assets, selection.include)
-    : assets
+    : rootAssets
   const excluded = new Set(
     resolveNamedAssets(assets, selection.exclude).map(asset => asset.id)
   )
@@ -532,11 +571,12 @@ export const resolveSelectedSkillAssetsWithDependencies = async (
   bundle: WorkspaceAssetBundle,
   selection?: WorkspaceSkillSelection
 ): Promise<Array<Extract<WorkspaceAsset, { kind: 'skill' }>>> => {
+  const rootAssets = bundle.skills.filter(asset => !isPluginSkillDependencyAsset(asset))
   const included = selection?.include != null && selection.include.length > 0
-    ? resolveNamedAssets(bundle.skills, selection.include)
-    : bundle.skills
+    ? resolveNamedSkillAssets(bundle, selection.include)
+    : rootAssets
   const excluded = new Set(
-    resolveNamedAssets(bundle.skills, selection?.exclude).map(asset => asset.id)
+    resolveNamedSkillAssets(bundle, selection?.exclude).map(asset => asset.id)
   )
   return await expandSkillAssetDependenciesWithRemoteResolution({
     allAssets: bundle.assets,

package/src/skill-dependencies.ts

@@ -1,14 +1,9 @@
 /* eslint-disable max-lines -- dependency normalization and graph expansion share the same local helpers */
-import { readFile } from 'node:fs/promises'
-
-import fm from 'front-matter'
-
-import { parseScopedReference, resolveSkillIdentifier } from '@vibe-forge/definition-core'
-import type { Config, Definition, Skill, WorkspaceAsset } from '@vibe-forge/types'
-import { formatSkillsSpec, parseSkillsSpec, resolveRelativePath } from '@vibe-forge/utils'
+import { parseScopedReference } from '@vibe-forge/definition-core'
+import type { Config, Skill, WorkspaceAsset } from '@vibe-forge/types'
+import { formatSkillsSpec, parseSkillsSpec } from '@vibe-forge/utils'
 
 import { HOME_BRIDGE_RESOLVED_BY } from './home-bridge'
-import { installSkillsCliDependency } from './skills-cli-dependency'
 
 type SkillAsset = Extract<WorkspaceAsset, { kind: 'skill' }>
 
@@ -106,39 +101,6 @@ const findSkillAssetByRef = (
   return resolveUniqueSkillByName(searchableAssets, ref)
 }
 
-const resolveDisplayName = (name: string, scope?: string) => (
-  scope != null && scope.trim() !== '' ? `${scope}/${name}` : name
-)
-
-const parseFrontmatterSkill = async (path: string): Promise<Definition<Skill>> => {
-  const content = await readFile(path, 'utf-8')
-  const { body, attributes } = fm<Skill>(content)
-  return {
-    path,
-    body,
-    attributes
-  }
-}
-
-const createResolvedSkillAsset = (params: {
-  cwd: string
-  definition: Definition<Skill>
-}) => {
-  const name = resolveSkillIdentifier(params.definition.path, params.definition.attributes.name)
-  const displayName = resolveDisplayName(name)
-  return {
-    id: `skill:workspace:workspace:${displayName}:${resolveRelativePath(params.cwd, params.definition.path)}`,
-    kind: 'skill',
-    name,
-    displayName,
-    origin: 'workspace',
-    sourcePath: params.definition.path,
-    payload: {
-      definition: params.definition
-    }
-  } satisfies SkillAsset
-}
-
 export const normalizeSkillDependency = (value: unknown): NormalizedSkillDependency | undefined => {
   const stringValue = asNonEmptyString(value)
   if (stringValue != null) return parseSkillsSpec(stringValue)
@@ -230,8 +192,6 @@ export const expandSkillAssetDependenciesWithRemoteResolution = async (
 ) => {
   const selected: SkillAsset[] = []
   const seen = new Set<string>()
-  const fetchedDependencyRefs = new Set<string>()
-
   const removeSupersededHomeBridgeSkill = (displayName: string) => {
     removeHomeBridgeSkillDuplicates(params.allAssets, displayName)
     removeHomeBridgeSkillDuplicates(params.skillAssets, displayName)
@@ -239,54 +199,6 @@ export const expandSkillAssetDependenciesWithRemoteResolution = async (
     removeHomeBridgeSkillDuplicates(selected, displayName)
   }
 
-  const installDependencyAsset = async (
-    dependency: NormalizedSkillDependency,
-    currentInstancePath?: string
-  ) => {
-    const fetchKey = dependency.ref
-    if (!fetchedDependencyRefs.has(fetchKey)) {
-      fetchedDependencyRefs.add(fetchKey)
-      const installed = await installSkillsCliDependency({
-        cwd: params.cwd,
-        configs: params.configs,
-        dependency
-      })
-      const definition = await parseFrontmatterSkill(installed.skillPath)
-      const dependencyAsset = createResolvedSkillAsset({
-        cwd: params.cwd,
-        definition
-      })
-      const existingAsset = findSkillDependencyAsset(
-        params.skillAssets,
-        dependency,
-        currentInstancePath,
-        { includeHomeBridge: false }
-      ) ??
-        params.skillAssets.find(existing => (
-          existing.resolvedBy !== HOME_BRIDGE_RESOLVED_BY &&
-          existing.displayName === dependencyAsset.displayName
-        ))
-      if (existingAsset != null) {
-        removeSupersededHomeBridgeSkill(existingAsset.displayName)
-        return existingAsset
-      }
-
-      removeSupersededHomeBridgeSkill(dependencyAsset.displayName)
-      params.allAssets.push(dependencyAsset)
-      params.skillAssets.push(dependencyAsset)
-      return dependencyAsset
-    }
-
-    // After the first fetch attempt, reuse whichever asset is now visible in the
-    // skill set: a newly installed registry skill, or a home-bridge fallback
-    // that was accepted by an earlier plain-name dependency resolution.
-    const resolvedAsset = findSkillDependencyAsset(params.skillAssets, dependency, currentInstancePath)
-    if (resolvedAsset != null && resolvedAsset.resolvedBy !== HOME_BRIDGE_RESOLVED_BY) {
-      removeSupersededHomeBridgeSkill(resolvedAsset.displayName)
-    }
-    return resolvedAsset
-  }
-
   const addAsset = async (asset: SkillAsset): Promise<void> => {
     if (params.excludedIds?.has(asset.id)) return
     if (seen.has(asset.id)) return
@@ -311,25 +223,15 @@ export const expandSkillAssetDependenciesWithRemoteResolution = async (
         continue
       }
 
-      // Keep registry-backed dependencies ahead of home-bridge skills. We only
-      // fall back to a bridged home skill for plain-name dependencies when the
-      // registry path is unavailable.
-      const dependencyAsset = await installDependencyAsset(dependency, asset.instancePath).catch((error: unknown) => {
-        if (
-          localOrBridgedDependency != null &&
-          dependency.source == null
-        ) {
-          return localOrBridgedDependency
-        }
-        throw error
-      }) ?? (
-        dependency.source == null
-          ? localOrBridgedDependency
-          : undefined
-      )
+      const dependencyAsset = dependency.source == null
+        ? localOrBridgedDependency
+        : undefined
 
       if (dependencyAsset == null) {
-        throw new Error(`Failed to resolve skill dependency ${dependency.ref} declared by ${asset.displayName}`)
+        throw new Error(
+          `Skill dependency ${dependency.ref} declared by ${asset.displayName} is missing. ` +
+            'Run vf skills install or vf skills update to materialize project skill dependencies.'
+        )
       }
       await addAsset(dependencyAsset)
     }

package/src/skills-cli-dependency-helpers.ts

@@ -1,94 +0,0 @@
-import { access, copyFile, lstat, mkdir, readdir } from 'node:fs/promises'
-import { dirname, resolve } from 'node:path'
-import process from 'node:process'
-
-import { withDirectoryInstallLock } from '@vibe-forge/utils/install-lock'
-import { resolveProjectSharedCachePath } from '@vibe-forge/utils/project-cache-path'
-import { toSkillSlug } from '@vibe-forge/utils/skills-cli'
-
-const toCacheSegment = (value: string) => (
-  value
-    .trim()
-    .toLowerCase()
-    .replace(/[^a-z0-9._-]+/g, '-')
-    .replace(/^-+|-+$/g, '') || 'default'
-)
-
-export const pathExists = async (targetPath: string) => {
-  try {
-    await access(targetPath)
-    return true
-  } catch {
-    return false
-  }
-}
-
-export const withInstallLock = async <T>(lockDir: string, callback: () => Promise<T>) => {
-  try {
-    return await withDirectoryInstallLock({ lockDir }, callback)
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error)
-    throw new Error(
-      message.replace('Timed out waiting for install lock', 'Timed out waiting for skill dependency install lock')
-    )
-  }
-}
-
-export const copyRegularFiles = async (sourceDir: string, targetDir: string) => {
-  let fileCount = 0
-  const entries = await readdir(sourceDir, { withFileTypes: true })
-
-  await mkdir(targetDir, { recursive: true })
-
-  for (const entry of entries) {
-    const sourcePath = resolve(sourceDir, entry.name)
-    const targetPath = resolve(targetDir, entry.name)
-    const stat = await lstat(sourcePath)
-
-    if (stat.isDirectory()) {
-      fileCount += await copyRegularFiles(sourcePath, targetPath)
-      continue
-    }
-
-    if (!stat.isFile()) continue
-
-    await mkdir(dirname(targetPath), { recursive: true })
-    await copyFile(sourcePath, targetPath)
-    fileCount += 1
-  }
-
-  return fileCount
-}
-
-export const pickSearchResult = <T extends { skill: string }>(
-  results: T[],
-  name: string
-) => {
-  const slug = toSkillSlug(name)
-  return results.find(result => (
-    result.skill === name ||
-    toSkillSlug(result.skill) === slug
-  )) ?? results[0]
-}
-
-export const buildInstallDir = (params: {
-  cwd: string
-  registry?: string
-  skill: string
-  source: string
-  version?: string
-}) => {
-  const registry = params.registry ?? 'default'
-  return resolveProjectSharedCachePath(
-    params.cwd,
-    process.env,
-    'skill-dependencies',
-    'skills-cli',
-    toCacheSegment('skills'),
-    toCacheSegment('latest'),
-    toCacheSegment(registry),
-    ...params.source.split('/').map(toCacheSegment),
-    toCacheSegment(params.version ?? 'latest'),
-    toCacheSegment(params.skill)
-  )
-}

package/src/skills-cli-dependency.ts

@@ -1,133 +0,0 @@
-import { mkdir, rename, rm } from 'node:fs/promises'
-import { resolve } from 'node:path'
-import process from 'node:process'
-
-import type { Config } from '@vibe-forge/types'
-import { isObjectSkillsConfig, resolveSkillsRegistry } from '@vibe-forge/utils'
-import { findSkillsCli, installSkillsCliRefToTemp, installSkillsCliSkillToTemp } from '@vibe-forge/utils/skills-cli'
-
-import type { NormalizedSkillDependency } from './skill-dependencies'
-import {
-  buildInstallDir,
-  copyRegularFiles,
-  pathExists,
-  pickSearchResult,
-  withInstallLock
-} from './skills-cli-dependency-helpers'
-
-const resolveAutoDownloadDependenciesEnabled = (
-  projectConfig: Config | undefined,
-  userConfig: Config | undefined
-) => (
-  (isObjectSkillsConfig(userConfig?.skills) ? userConfig.skills.autoDownloadDependencies : undefined) ??
-    (isObjectSkillsConfig(projectConfig?.skills) ? projectConfig.skills.autoDownloadDependencies : undefined) ??
-    true
-)
-
-export const installSkillsCliDependency = async (params: {
-  cwd: string
-  configs: [Config?, Config?]
-  dependency: NormalizedSkillDependency
-}) => {
-  const [projectConfig, userConfig] = params.configs
-  const autoDownloadDependenciesEnabled = resolveAutoDownloadDependenciesEnabled(projectConfig, userConfig)
-  const defaultRegistry = resolveSkillsRegistry(params.configs[1]?.skills) ??
-    resolveSkillsRegistry(params.configs[0]?.skills)
-  const registry = params.dependency.registry ?? defaultRegistry
-  const resolvedTarget = await (async () => {
-    if (params.dependency.source != null) {
-      return {
-        skill: params.dependency.name,
-        source: params.dependency.source
-      }
-    }
-
-    if (!autoDownloadDependenciesEnabled) {
-      throw new Error(
-        `Skill dependency automatic downloads are disabled; cannot resolve ${params.dependency.ref} without a source`
-      )
-    }
-
-    return await (async () => {
-      const searchResults = await findSkillsCli({
-        registry,
-        query: params.dependency.name
-      })
-      const selected = pickSearchResult(searchResults, params.dependency.name)
-      if (selected == null) {
-        throw new Error(`Skill ${params.dependency.name} was not found by the skills CLI search.`)
-      }
-
-      return {
-        installRef: selected.installRef,
-        skill: selected.skill,
-        source: selected.source
-      }
-    })()
-  })()
-
-  const installDir = buildInstallDir({
-    cwd: params.cwd,
-    registry,
-    skill: resolvedTarget.skill,
-    source: resolvedTarget.source,
-    version: params.dependency.version
-  })
-  const skillPath = resolve(installDir, 'SKILL.md')
-
-  return await withInstallLock(`${installDir}.lock`, async () => {
-    if (await pathExists(skillPath)) {
-      return {
-        installDir,
-        skillPath
-      }
-    }
-
-    if (!autoDownloadDependenciesEnabled) {
-      throw new Error(`Skill dependency automatic downloads are disabled; cache not found for ${params.dependency.ref}`)
-    }
-
-    const tempInstallDir = `${installDir}.tmp-${process.pid}-${Date.now()}-${Math.random().toString(36).slice(2)}`
-    await rm(tempInstallDir, { recursive: true, force: true })
-    await mkdir(tempInstallDir, { recursive: true })
-
-    const installResult = 'installRef' in resolvedTarget
-      ? params.dependency.version == null
-        ? await installSkillsCliRefToTemp({
-          installRef: resolvedTarget.installRef,
-          registry
-        })
-        : await installSkillsCliSkillToTemp({
-          registry,
-          skill: resolvedTarget.skill,
-          source: resolvedTarget.source,
-          version: params.dependency.version
-        })
-      : await installSkillsCliSkillToTemp({
-        registry,
-        skill: resolvedTarget.skill,
-        source: resolvedTarget.source,
-        version: params.dependency.version
-      })
-
-    try {
-      await copyRegularFiles(installResult.installedSkill.sourcePath, tempInstallDir)
-      if (!await pathExists(resolve(tempInstallDir, 'SKILL.md'))) {
-        throw new Error(`Skill dependency ${params.dependency.ref} did not include SKILL.md`)
-      }
-
-      await rm(installDir, { recursive: true, force: true })
-      await rename(tempInstallDir, installDir)
-    } catch (error) {
-      await rm(tempInstallDir, { recursive: true, force: true })
-      throw error
-    } finally {
-      await rm(installResult.tempDir, { recursive: true, force: true })
-    }
-
-    return {
-      installDir,
-      skillPath
-    }
-  })
-}