@vibe-forge/workspace-assets 2.0.1 → 2.0.2

package/__tests__/skill-dependencies-cli.spec.ts

@@ -1,175 +0,0 @@
-/* eslint-disable import/first -- hoisted vitest mocks must be declared before importing the bundle entrypoint */
-import { mkdir, mkdtemp, rm, writeFile } from 'node:fs/promises'
-import os from 'node:os'
-import path, { join } from 'node:path'
-
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
-
-const mocks = vi.hoisted(() => ({
-  findSkillsCli: vi.fn(),
-  installSkillsCliRefToTemp: vi.fn(),
-  installSkillsCliSkillToTemp: vi.fn()
-}))
-
-vi.mock('@vibe-forge/utils/skills-cli', async () => {
-  const actual = await vi.importActual<typeof import('@vibe-forge/utils/skills-cli')>('@vibe-forge/utils/skills-cli')
-  return {
-    ...actual,
-    findSkillsCli: mocks.findSkillsCli,
-    installSkillsCliRefToTemp: mocks.installSkillsCliRefToTemp,
-    installSkillsCliSkillToTemp: mocks.installSkillsCliSkillToTemp
-  }
-})
-
-import { buildAdapterAssetPlan, resolveWorkspaceAssetBundle } from '#~/index.js'
-
-import { createWorkspace, writeDocument } from './test-helpers'
-
-describe('skills CLI dependency resolution', () => {
-  let installWorkspace: string
-
-  beforeEach(async () => {
-    installWorkspace = await mkdtemp(path.join(os.tmpdir(), 'vf-skills-cli-dependency-'))
-    vi.clearAllMocks()
-  })
-
-  afterEach(async () => {
-    await rm(installWorkspace, { recursive: true, force: true })
-  })
-
-  it('installs missing bare-name dependencies through skills CLI by default', async () => {
-    const workspace = await createWorkspace()
-    const installedSkillDir = join(installWorkspace, '.agents', 'skills', 'frontend-design')
-    await mkdir(installedSkillDir, { recursive: true })
-    await writeFile(
-      join(installedSkillDir, 'SKILL.md'),
-      '---\nname: frontend-design\ndescription: UI design guidance\n---\nUse strong visual hierarchy.\n'
-    )
-
-    mocks.findSkillsCli.mockResolvedValue([
-      {
-        installRef: 'anthropics/skills@frontend-design',
-        source: 'anthropics/skills',
-        skill: 'frontend-design'
-      }
-    ])
-    mocks.installSkillsCliRefToTemp.mockResolvedValue({
-      tempDir: installWorkspace,
-      installedSkill: {
-        dirName: 'frontend-design',
-        name: 'frontend-design',
-        sourcePath: installedSkillDir
-      }
-    })
-
-    await writeDocument(
-      join(workspace, '.ai/skills/app-builder/SKILL.md'),
-      [
-        '---',
-        'name: app-builder',
-        'description: Build apps',
-        'dependencies:',
-        '  - frontend-design',
-        '---',
-        'Build the app.'
-      ].join('\n')
-    )
-
-    const bundle = await resolveWorkspaceAssetBundle({
-      cwd: workspace,
-      configs: [undefined, undefined],
-      useDefaultVibeForgeMcpServer: false
-    })
-
-    await buildAdapterAssetPlan({
-      adapter: 'opencode',
-      bundle,
-      options: {
-        skills: {
-          include: ['app-builder']
-        }
-      }
-    })
-
-    const dependency = bundle.skills.find(asset => asset.name === 'frontend-design')
-    expect(bundle.skills.map(asset => asset.name).sort()).toEqual(['app-builder', 'frontend-design'])
-    expect(dependency?.sourcePath).toContain(
-      '/.ai/caches/skill-dependencies/skills-cli/skills/latest/default/anthropics/skills/frontend-design/'
-    )
-    expect(mocks.findSkillsCli).toHaveBeenCalledWith({
-      config: undefined,
-      query: 'frontend-design'
-    })
-    expect(mocks.installSkillsCliRefToTemp).toHaveBeenCalledWith({
-      config: undefined,
-      installRef: 'anthropics/skills@frontend-design'
-    })
-  })
-
-  it('merges top-level skillsCli config ahead of legacy skills.cli aliases', async () => {
-    const workspace = await createWorkspace()
-    const installedSkillDir = join(installWorkspace, '.agents', 'skills', 'frontend-design')
-    await mkdir(installedSkillDir, { recursive: true })
-    await writeFile(
-      join(installedSkillDir, 'SKILL.md'),
-      '---\nname: frontend-design\ndescription: UI design guidance\n---\nUse internal design system.\n'
-    )
-
-    mocks.installSkillsCliSkillToTemp.mockResolvedValue({
-      tempDir: installWorkspace,
-      installedSkill: {
-        dirName: 'frontend-design',
-        name: 'frontend-design',
-        sourcePath: installedSkillDir
-      }
-    })
-
-    await writeDocument(
-      join(workspace, '.ai/skills/app-builder/SKILL.md'),
-      [
-        '---',
-        'name: app-builder',
-        'description: Build apps',
-        'dependencies:',
-        '  - example-source/default/public@frontend-design',
-        '---',
-        'Build the app.'
-      ].join('\n')
-    )
-
-    const bundle = await resolveWorkspaceAssetBundle({
-      cwd: workspace,
-      configs: [{
-        skills: {
-          cli: {
-            package: 'legacy-skills'
-          }
-        },
-        skillsCli: {
-          package: '@byted/skills',
-          registry: 'https://registry.example.com'
-        }
-      }, undefined],
-      useDefaultVibeForgeMcpServer: false
-    })
-
-    await buildAdapterAssetPlan({
-      adapter: 'opencode',
-      bundle,
-      options: {
-        skills: {
-          include: ['app-builder']
-        }
-      }
-    })
-
-    expect(mocks.installSkillsCliSkillToTemp).toHaveBeenCalledWith({
-      config: {
-        package: '@byted/skills',
-        registry: 'https://registry.example.com'
-      },
-      skill: 'frontend-design',
-      source: 'example-source/default/public'
-    })
-  })
-})

package/src/configured-skills.ts

@@ -1,99 +0,0 @@
-import { access } from 'node:fs/promises'
-import process from 'node:process'
-
-import type { Config, ConfiguredSkillInstallConfig, SkillsCliConfig } from '@vibe-forge/types'
-import {
-  installProjectSkill,
-  normalizeProjectSkillInstall,
-  resolveConfiguredSkillInstalls as resolveDeclaredConfiguredSkillInstalls,
-  resolveProjectAiPath,
-  resolveSkillsCliRuntimeConfig
-} from '@vibe-forge/utils'
-import type { NormalizedProjectSkillInstall } from '@vibe-forge/utils'
-
-const resolveConfiguredSkillsCliConfig = (configs: [Config?, Config?]) => {
-  const [projectConfig, userConfig] = configs
-  const merged = {
-    ...(resolveSkillsCliRuntimeConfig(projectConfig) ?? {}),
-    ...(resolveSkillsCliRuntimeConfig(userConfig) ?? {})
-  } satisfies SkillsCliConfig
-
-  return Object.keys(merged).length === 0 ? undefined : merged
-}
-
-const resolveConfiguredSkillInstalls = (configs: [Config?, Config?]) => (
-  [
-    ...resolveDeclaredConfiguredSkillInstalls(configs[0]?.skills),
-    ...resolveDeclaredConfiguredSkillInstalls(configs[1]?.skills)
-  ]
-    .map((item) => normalizeProjectSkillInstall(item as string | ConfiguredSkillInstallConfig))
-    .filter((item): item is NormalizedProjectSkillInstall => item != null)
-)
-
-const pathExists = async (targetPath: string) => {
-  try {
-    await access(targetPath)
-    return true
-  } catch {
-    return false
-  }
-}
-
-const ensureUniqueTargets = (skills: NormalizedProjectSkillInstall[]) => {
-  const seen = new Map<string, string>()
-
-  for (const skill of skills) {
-    const previous = seen.get(skill.targetDirName)
-    if (previous != null) {
-      throw new Error(
-        `Configured skills "${previous}" and "${skill.ref}" resolve to the same target "${skill.targetDirName}"`
-      )
-    }
-    seen.set(skill.targetDirName, skill.ref)
-  }
-}
-
-export const ensureConfiguredProjectSkills = async (params: {
-  configs: [Config?, Config?]
-  updateInstalledSkills?: boolean
-  workspaceFolder: string
-}) => {
-  const installs = resolveConfiguredSkillInstalls(params.configs)
-  if (installs.length === 0) {
-    return []
-  }
-
-  ensureUniqueTargets(installs)
-
-  const skillsCliConfig = resolveConfiguredSkillsCliConfig(params.configs)
-  const ensured: Array<{ dirName: string; skillPath: string }> = []
-
-  for (const skill of installs) {
-    const skillPath = resolveProjectAiPath(
-      params.workspaceFolder,
-      process.env,
-      'skills',
-      skill.targetDirName,
-      'SKILL.md'
-    )
-    if (params.updateInstalledSkills !== true && await pathExists(skillPath)) {
-      ensured.push({
-        dirName: skill.targetDirName,
-        skillPath
-      })
-      continue
-    }
-
-    ensured.push(
-      await installProjectSkill({
-        config: skillsCliConfig,
-        force: true,
-        registry: undefined,
-        skill,
-        workspaceFolder: params.workspaceFolder
-      })
-    )
-  }
-
-  return ensured
-}

package/src/skills-cli-dependency.ts

@@ -1,208 +0,0 @@
-import { access, copyFile, lstat, mkdir, readdir, rename, rm } from 'node:fs/promises'
-import { dirname, resolve } from 'node:path'
-import process from 'node:process'
-import { setTimeout as delay } from 'node:timers/promises'
-
-import type { Config, SkillsCliConfig } from '@vibe-forge/types'
-import { resolveSkillsCliRuntimeConfig } from '@vibe-forge/utils'
-import { resolveProjectSharedCachePath } from '@vibe-forge/utils/project-cache-path'
-import {
-  findSkillsCli,
-  installSkillsCliRefToTemp,
-  installSkillsCliSkillToTemp,
-  resolveSkillsCliRegistry,
-  toSkillSlug
-} from '@vibe-forge/utils/skills-cli'
-
-import type { NormalizedSkillDependency } from './skill-dependencies'
-
-const INSTALL_LOCK_TIMEOUT_MS = 30_000
-const INSTALL_LOCK_RETRY_MS = 100
-
-const toCacheSegment = (value: string) => (
-  value
-    .trim()
-    .toLowerCase()
-    .replace(/[^a-z0-9._-]+/g, '-')
-    .replace(/^-+|-+$/g, '') || 'default'
-)
-
-const pathExists = async (targetPath: string) => {
-  try {
-    await access(targetPath)
-    return true
-  } catch {
-    return false
-  }
-}
-
-const withInstallLock = async <T>(lockDir: string, callback: () => Promise<T>) => {
-  const start = Date.now()
-  await mkdir(dirname(lockDir), { recursive: true })
-
-  while (true) {
-    try {
-      await mkdir(lockDir)
-      break
-    } catch (error) {
-      if ((error as NodeJS.ErrnoException).code !== 'EEXIST') throw error
-      if (Date.now() - start > INSTALL_LOCK_TIMEOUT_MS) {
-        throw new Error(`Timed out waiting for skill dependency install lock ${lockDir}`)
-      }
-      await delay(INSTALL_LOCK_RETRY_MS)
-    }
-  }
-
-  try {
-    return await callback()
-  } finally {
-    await rm(lockDir, { recursive: true, force: true })
-  }
-}
-
-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
-}
-
-const pickSearchResult = (results: Awaited<ReturnType<typeof findSkillsCli>>, name: string) => {
-  const slug = toSkillSlug(name)
-  return results.find(result => (
-    result.skill === name ||
-    toSkillSlug(result.skill) === slug
-  )) ?? results[0]
-}
-
-const resolveConfiguredSkillsCliConfig = (configs: [Config?, Config?]) => {
-  const [projectConfig, userConfig] = configs
-  const merged = {
-    ...(resolveSkillsCliRuntimeConfig(projectConfig) ?? {}),
-    ...(resolveSkillsCliRuntimeConfig(userConfig) ?? {})
-  } satisfies SkillsCliConfig
-
-  return Object.keys(merged).length === 0 ? undefined : merged
-}
-
-const buildInstallDir = (params: {
-  config?: SkillsCliConfig
-  cwd: string
-  skill: string
-  source: string
-}) => {
-  const registry = resolveSkillsCliRegistry({
-    config: params.config
-  }) ?? 'default'
-  return resolveProjectSharedCachePath(
-    params.cwd,
-    process.env,
-    'skill-dependencies',
-    'skills-cli',
-    toCacheSegment(params.config?.package ?? 'skills'),
-    toCacheSegment(params.config?.version ?? 'latest'),
-    toCacheSegment(registry),
-    ...params.source.split('/').map(toCacheSegment),
-    toCacheSegment(params.skill)
-  )
-}
-
-export const installSkillsCliDependency = async (params: {
-  cwd: string
-  configs: [Config?, Config?]
-  dependency: NormalizedSkillDependency
-}) => {
-  const config = resolveConfiguredSkillsCliConfig(params.configs)
-  const resolvedTarget = params.dependency.source != null
-    ? {
-      skill: params.dependency.name,
-      source: params.dependency.source
-    }
-    : await (async () => {
-      const searchResults = await findSkillsCli({
-        config,
-        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({
-    config,
-    cwd: params.cwd,
-    skill: resolvedTarget.skill,
-    source: resolvedTarget.source
-  })
-  const skillPath = resolve(installDir, 'SKILL.md')
-
-  return await withInstallLock(`${installDir}.lock`, async () => {
-    if (await pathExists(skillPath)) {
-      return {
-        installDir,
-        skillPath
-      }
-    }
-
-    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
-      ? await installSkillsCliRefToTemp({
-        config,
-        installRef: resolvedTarget.installRef
-      })
-      : await installSkillsCliSkillToTemp({
-        config,
-        skill: resolvedTarget.skill,
-        source: resolvedTarget.source
-      })
-
-    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
-    }
-  })
-}