@vibe-forge/workspace-assets 2.0.1 → 2.0.3

package/__tests__/prompt-builders.spec.ts

@@ -9,6 +9,7 @@ import {
   generateSkillsRoutePrompt,
   generateSpecRoutePrompt
 } from '#~/prompt-builders.js'
+import { generateWorkspaceRoutePrompt } from '#~/workspace-prompt.js'
 
 describe('workspace asset prompt builders', () => {
   it('builds skill prompts with stable names, descriptions, and relative paths', () => {
@@ -175,12 +176,50 @@ describe('workspace asset prompt builders', () => {
     expect(prompt).toContain('reviewer: 负责代码审查')
     expect(prompt).toContain('`VibeForge.StartTasks`')
     expect(prompt).toContain('`VibeForge.GetTaskInfo`')
+    expect(prompt).toContain('Task tool guide:')
+    expect(prompt).toContain('After starting a task')
+    expect(prompt).toContain('10 most recent log entries')
+    expect(prompt).toContain('`logLimit`')
+    expect(prompt).toContain('`logOrder`')
+    expect(prompt).toContain('`VibeForge.SendTaskMessage`')
+    expect(prompt).toContain('`{ taskId, message, mode }`')
+    expect(prompt).toContain('Choose `mode: "direct"`')
+    expect(prompt).toContain('Choose `mode: "steer"`')
+    expect(prompt).toContain('`VibeForge.SubmitTaskInput`')
+    expect(prompt).toContain('Do not use it for ordinary follow-up instructions or queued steer turns')
+    expect(prompt).toContain('If a task is `completed` or `failed`')
     expect(prompt).toContain('`wait`')
     expect(prompt).not.toContain('run-tasks')
     expect(prompt).not.toContain('需要关注变更风险')
     expect(prompt).not.toContain('hidden')
   })
 
+  it('builds workspace routes with managed task guidance', () => {
+    const cwd = '/tmp/project'
+
+    const prompt = generateWorkspaceRoutePrompt(cwd, [
+      {
+        id: 'billing',
+        cwd: join(cwd, 'packages/billing'),
+        path: join(cwd, '.ai/workspaces/billing.md'),
+        description: 'Billing workspace'
+      }
+    ])
+
+    expect(prompt).toContain('The project includes the following registered workspaces')
+    expect(prompt).toContain('Identifier: billing')
+    expect(prompt).toContain('`VibeForge.StartTasks`')
+    expect(prompt).toContain('type: "workspace"')
+    expect(prompt).toContain('Task tool guide:')
+    expect(prompt).toContain('`VibeForge.GetTaskInfo`')
+    expect(prompt).toContain('`VibeForge.ListTasks`')
+    expect(prompt).toContain('`VibeForge.SendTaskMessage`')
+    expect(prompt).toContain('`VibeForge.SubmitTaskInput`')
+    expect(prompt).toContain('Choose `mode: "direct"`')
+    expect(prompt).toContain('Choose `mode: "steer"`')
+    expect(prompt).toContain('Do not directly edit files inside a registered workspace')
+  })
+
   it('builds skill route prompts without preloading content', () => {
     const cwd = '/tmp/project'
 

package/__tests__/skill-dependencies.spec.ts

@@ -0,0 +1,80 @@
+import { join } from 'node:path'
+
+import { afterEach, describe, expect, it, vi } from 'vitest'
+
+import { buildAdapterAssetPlan, resolveWorkspaceAssetBundle } from '#~/index.js'
+import { normalizeSkillDependency } from '#~/skill-dependencies.js'
+
+import { createWorkspace, writeDocument } from './test-helpers'
+
+afterEach(() => {
+  vi.unstubAllGlobals()
+})
+
+describe('skill dependency normalization', () => {
+  it('parses legacy non-structured registry strings', () => {
+    expect(
+      normalizeSkillDependency('https://bnpm.byted.org@skills.byted.org/lynx/skills@lynx-devtool@1.0.3')
+    ).toEqual({
+      ref: 'https://bnpm.byted.org@skills.byted.org/lynx/skills@lynx-devtool@1.0.3',
+      name: 'lynx-devtool',
+      source: 'lynx/skills',
+      registry: 'https://skills.byted.org',
+      version: '1.0.3',
+      packageRegistry: 'https://bnpm.byted.org'
+    })
+  })
+
+  it('installs legacy non-structured registry dependencies through the skill registry API', async () => {
+    const workspace = await createWorkspace()
+    const fetchMock = vi.fn(async (url: string) => {
+      if (url === 'https://skills.byted.org/api/download/lynx/skills/lynx-devtool?version=1.0.3') {
+        return new Response(JSON.stringify({
+          files: [{
+            path: 'SKILL.md',
+            contents: '---\nname: lynx-devtool\ndescription: Lynx device debugging\n---\nUse devtool.\n'
+          }]
+        }))
+      }
+      return new Response('not found', { status: 404 })
+    })
+    vi.stubGlobal('fetch', fetchMock)
+
+    await writeDocument(
+      join(workspace, '.ai/skills/debug-lynx/SKILL.md'),
+      [
+        '---',
+        'name: debug-lynx',
+        'description: Debug Lynx on device',
+        'dependencies:',
+        '  - https://bnpm.byted.org@skills.byted.org/lynx/skills@lynx-devtool@1.0.3',
+        '---',
+        'Run the full debugging workflow.'
+      ].join('\n')
+    )
+
+    const bundle = await resolveWorkspaceAssetBundle({
+      cwd: workspace,
+      configs: [undefined, undefined],
+      useDefaultVibeForgeMcpServer: false
+    })
+
+    await buildAdapterAssetPlan({
+      adapter: 'opencode',
+      bundle,
+      options: {
+        skills: {
+          include: ['debug-lynx']
+        }
+      }
+    })
+
+    expect(fetchMock).toHaveBeenCalledWith(
+      'https://skills.byted.org/api/download/lynx/skills/lynx-devtool?version=1.0.3',
+      expect.any(Object)
+    )
+    expect(bundle.skills.find(asset => asset.name === 'lynx-devtool')?.sourcePath).toContain(
+      '/.ai/caches/skill-dependencies/skills.byted.org/lynx/skills/lynx-devtool/1.0.3/'
+    )
+  })
+})

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vibe-forge/workspace-assets",
-  "version": "2.0.1",
+  "version": "2.0.3",
   "description": "Workspace asset resolution and adapter asset planning for Vibe Forge",
   "imports": {
     "#~/*.js": {
@@ -30,9 +30,9 @@
     "fast-glob": "^3.3.3",
     "front-matter": "^4.0.2",
     "js-yaml": "^4.1.1",
-    "@vibe-forge/utils": "^2.0.1",
-    "@vibe-forge/types": "^2.0.1",
-    "@vibe-forge/definition-core": "^2.0.1"
+    "@vibe-forge/types": "^2.0.2",
+    "@vibe-forge/utils": "^2.0.3",
+    "@vibe-forge/definition-core": "^2.0.0"
   },
   "devDependencies": {
     "@types/js-yaml": "^4.0.9"

package/src/bundle-internal.ts

@@ -9,12 +9,7 @@ import {
   resolveDefaultVibeForgeMcpServerConfig
 } from '@vibe-forge/config'
 import type { Config, Definition, Entity, PluginConfig, WorkspaceAsset, WorkspaceAssetKind } from '@vibe-forge/types'
-import {
-  isLegacySkillsConfig,
-  resolveProjectAiBaseDir,
-  resolveProjectAiEntitiesDir,
-  resolveRelativePath
-} from '@vibe-forge/utils'
+import { resolveProjectAiBaseDir, resolveProjectAiEntitiesDir, resolveRelativePath } from '@vibe-forge/utils'
 import { listManagedPluginInstalls, toManagedPluginConfig } from '@vibe-forge/utils/managed-plugin'
 import {
   flattenPluginInstances,
@@ -33,7 +28,6 @@ import {
   resolveSkillIdentifier,
   resolveSpecIdentifier
 } from '@vibe-forge/definition-core'
-import { ensureConfiguredProjectSkills } from './configured-skills'
 import { HOME_BRIDGE_RESOLVED_BY } from './home-bridge'
 import { resolveConfiguredWorkspaceAssets } from './workspaces'
 
@@ -159,8 +153,8 @@ const warnInvalidHomeSkillRoot = (root: string) => {
 
 const resolveHomeBridgeConfig = (configs: [Config?, Config?]) => {
   const [config, userConfig] = configs
-  const projectHomeBridge = isLegacySkillsConfig(config?.skills) ? config.skills.homeBridge : undefined
-  const userHomeBridge = isLegacySkillsConfig(userConfig?.skills) ? userConfig.skills.homeBridge : undefined
+  const projectHomeBridge = config?.skills?.homeBridge
+  const userHomeBridge = userConfig?.skills?.homeBridge
 
   return {
     enabled: userHomeBridge?.enabled ?? projectHomeBridge?.enabled ?? true,
@@ -532,8 +526,6 @@ export async function collectWorkspaceAssets(params: {
   plugins?: PluginConfig
   overlaySource?: string
   includeManagedPlugins?: boolean
-  syncConfiguredSkills?: boolean
-  updateConfiguredSkills?: boolean
   useDefaultVibeForgeMcpServer?: boolean
 }): Promise<{
   assets: WorkspaceAsset[]
@@ -552,13 +544,6 @@ export async function collectWorkspaceAssets(params: {
   workspaces: Array<Extract<WorkspaceAsset, { kind: 'workspace' }>>
 }> {
   const [config, userConfig] = params.configs ?? await loadWorkspaceConfig(params.cwd)
-  if (params.syncConfiguredSkills === true) {
-    await ensureConfiguredProjectSkills({
-      configs: [config, userConfig],
-      updateInstalledSkills: params.updateConfiguredSkills,
-      workspaceFolder: params.cwd
-    })
-  }
   const managedPluginConfigs = params.includeManagedPlugins === false
     ? undefined
     : toManagedPluginConfig(await listManagedPluginInstalls(params.cwd))

package/src/bundle.ts

@@ -8,8 +8,6 @@ export async function resolveWorkspaceAssetBundle(params: {
   plugins?: PluginConfig
   overlaySource?: string
   includeManagedPlugins?: boolean
-  syncConfiguredSkills?: boolean
-  updateConfiguredSkills?: boolean
   useDefaultVibeForgeMcpServer?: boolean
 }): Promise<WorkspaceAssetBundle> {
   const collected = await collectWorkspaceAssets(params)

package/src/prompt-builders.ts

@@ -7,6 +7,8 @@ import {
 import type { Definition, Entity, Rule, Skill, Spec } from '@vibe-forge/types'
 import { CANONICAL_VIBE_FORGE_MCP_SERVER_NAME, resolvePromptPath } from '@vibe-forge/utils'
 
+import { buildManagedTaskToolGuidance } from './task-tool-guidance'
+
 const toMarkdownBlockquote = (content: string) => (
   content
     .trim()
@@ -165,6 +167,7 @@ export const generateSpecRoutePrompt = (
 }
 
 export const generateEntitiesRoutePrompt = (entities: Definition<Entity>[]) => {
+  const taskToolGuidance = buildManagedTaskToolGuidance(CANONICAL_VIBE_FORGE_MCP_SERVER_NAME)
   return (
     '<system-prompt>\n' +
     'The project includes the following entities:\n' +
@@ -179,6 +182,7 @@ export const generateEntitiesRoutePrompt = (entities: Definition<Entity>[]) => {
         .join('')
     }\n` +
     `When solving user problems, you may specify entities through \`${CANONICAL_VIBE_FORGE_MCP_SERVER_NAME}.StartTasks\` as needed and have them coordinate multiple entity types to complete the work; use \`${CANONICAL_VIBE_FORGE_MCP_SERVER_NAME}.GetTaskInfo\` and \`wait\` to track progress.\n` +
+    `${taskToolGuidance}\n` +
     '</system-prompt>\n'
   )
 }

package/src/prompt-selection.ts

@@ -35,7 +35,7 @@ import {
   resolveSelectedSkillAssetsWithDependencies,
   toDocumentDefinitions
 } from './selection-internal'
-import { expandSkillAssetDependenciesWithRemoteResolution } from './skill-dependencies'
+import { expandSkillAssetDependenciesWithRegistry } from './skill-dependencies'
 import { generateWorkspaceRoutePrompt } from './workspace-prompt'
 
 export async function resolvePromptAssetSelection(params: {
@@ -164,7 +164,7 @@ export async function resolvePromptAssetSelection(params: {
       resolveNamedAssets(effectiveBundle.skills, excludedRefs, targetInstancePath).map(asset => asset.id)
     )
 
-    const expandedTargetSkills = await expandSkillAssetDependenciesWithRemoteResolution({
+    const expandedTargetSkills = await expandSkillAssetDependenciesWithRegistry({
       allAssets: effectiveBundle.assets,
       configs: effectiveBundle.configs ?? [undefined, undefined],
       cwd: effectiveBundle.cwd,

package/src/selection-internal.ts

@@ -26,7 +26,7 @@ import {
   isRemoteRuleReference,
   parseScopedReference
 } from '@vibe-forge/definition-core'
-import { expandSkillAssetDependencies, expandSkillAssetDependenciesWithRemoteResolution } from './skill-dependencies'
+import { expandSkillAssetDependencies, expandSkillAssetDependenciesWithRegistry } from './skill-dependencies'
 
 type DocumentAssetKind = Extract<WorkspaceAssetKind, 'rule' | 'spec' | 'entity' | 'skill'>
 type DocumentAsset<TDefinition> = Extract<WorkspaceAsset, { kind: DocumentAssetKind }> & {
@@ -538,7 +538,7 @@ export const resolveSelectedSkillAssetsWithDependencies = async (
   const excluded = new Set(
     resolveNamedAssets(bundle.skills, selection?.exclude).map(asset => asset.id)
   )
-  return await expandSkillAssetDependenciesWithRemoteResolution({
+  return await expandSkillAssetDependenciesWithRegistry({
     allAssets: bundle.assets,
     configs: bundle.configs ?? [undefined, undefined],
     cwd: bundle.cwd,

package/src/skill-dependencies.ts

@@ -8,7 +8,7 @@ import type { Config, Definition, Skill, WorkspaceAsset } from '@vibe-forge/type
 import { resolveRelativePath } from '@vibe-forge/utils'
 
 import { HOME_BRIDGE_RESOLVED_BY } from './home-bridge'
-import { installSkillsCliDependency } from './skills-cli-dependency'
+import { installRegistrySkillDependency } from './skill-registry'
 
 type SkillAsset = Extract<WorkspaceAsset, { kind: 'skill' }>
 
@@ -16,6 +16,9 @@ export interface NormalizedSkillDependency {
   ref: string
   name: string
   source?: string
+  registry?: string
+  version?: string
+  packageRegistry?: string
 }
 
 interface DependencyExpansionParams {
@@ -41,6 +44,29 @@ const toSkillSlug = (value: string) => (
     .replace(/^-|-$/g, '')
 )
 
+const trimSlashes = (value: string) => value.replace(/^\/+|\/+$/g, '')
+
+const normalizeLegacyUrl = (value: string) => {
+  const trimmed = value.trim()
+  if (trimmed === '') return undefined
+  const candidate = /^[a-z][a-z\d+.-]*:\/\//i.test(trimmed) ? trimmed : `https://${trimmed}`
+  try {
+    return new URL(candidate)
+  } catch {
+    return undefined
+  }
+}
+
+const buildDependencyRef = (params: {
+  name: string
+  source?: string
+  version?: string
+}) => (
+  params.source == null
+    ? (params.version == null ? params.name : `${params.name}@${params.version}`)
+    : `${params.source}@${params.name}${params.version == null ? '' : `@${params.version}`}`
+)
+
 const resolveUniqueSkillByName = (assets: SkillAsset[], name: string) => {
   const nameSlug = toSkillSlug(name)
   const matches = assets.filter(asset => asset.name === name || toSkillSlug(asset.name) === nameSlug)
@@ -118,7 +144,7 @@ const parseFrontmatterSkill = async (path: string): Promise<Definition<Skill>> =
   }
 }
 
-const createResolvedSkillAsset = (params: {
+const createRegistrySkillAsset = (params: {
   cwd: string
   definition: Definition<Skill>
 }) => {
@@ -137,8 +163,38 @@ const createResolvedSkillAsset = (params: {
   } satisfies SkillAsset
 }
 
+const parseLegacyRegistryDependency = (value: string): NormalizedSkillDependency | undefined => {
+  const ref = value.trim()
+  const segments = ref.split('@').map(segment => segment.trim())
+  if (segments.length < 3) return undefined
+
+  const hasVersion = segments.length >= 4
+  const nameIndex = hasVersion ? segments.length - 2 : segments.length - 1
+  const packageRegistry = normalizeLegacyUrl(segments[0] ?? '')
+  const sourceUrl = normalizeLegacyUrl(segments.slice(1, nameIndex).join('@'))
+  const name = asNonEmptyString(segments[nameIndex])
+  const version = hasVersion ? asNonEmptyString(segments[segments.length - 1]) : undefined
+
+  if (packageRegistry == null || sourceUrl == null || name == null) return undefined
+
+  const source = trimSlashes(sourceUrl.pathname)
+  if (source === '') return undefined
+
+  return {
+    ref,
+    name,
+    source,
+    registry: sourceUrl.origin,
+    ...(version == null ? {} : { version }),
+    packageRegistry: packageRegistry.toString().replace(/\/+$/, '')
+  }
+}
+
 const parseStringDependency = (value: string): NormalizedSkillDependency => {
   const ref = value.trim()
+  const legacyRegistryDependency = parseLegacyRegistryDependency(ref)
+  if (legacyRegistryDependency != null) return legacyRegistryDependency
+
   const atIndex = ref.lastIndexOf('@')
   if (atIndex > 0 && atIndex < ref.length - 1) {
     return {
@@ -148,15 +204,12 @@ const parseStringDependency = (value: string): NormalizedSkillDependency => {
     }
   }
 
-  const sourcePathSegments = ref.split('/').filter(segment => segment.trim() !== '')
-  if (
-    sourcePathSegments.length >= 3 &&
-    sourcePathSegments.every(segment => !segment.includes(' '))
-  ) {
+  const sourcePathMatch = ref.match(/^([^/\s]+\/[^/\s]+)\/([^/\s]+)$/)
+  if (sourcePathMatch != null) {
     return {
       ref,
-      source: sourcePathSegments.slice(0, -1).join('/'),
-      name: sourcePathSegments[sourcePathSegments.length - 1]
+      source: sourcePathMatch[1],
+      name: sourcePathMatch[2]
     }
   }
 
@@ -176,10 +229,17 @@ export const normalizeSkillDependency = (value: unknown): NormalizedSkillDepende
   if (name == null) return undefined
 
   const source = asNonEmptyString(record.source)
+  const version = asNonEmptyString(record.version)
   return {
-    ref: source == null ? name : `${source}@${name}`,
+    ref: buildDependencyRef({
+      name,
+      ...(source == null ? {} : { source }),
+      ...(version == null ? {} : { version })
+    }),
     name,
-    ...(source == null ? {} : { source })
+    ...(source == null ? {} : { source }),
+    ...(asNonEmptyString(record.registry) == null ? {} : { registry: asNonEmptyString(record.registry) }),
+    ...(version == null ? {} : { version })
   }
 }
 
@@ -243,7 +303,7 @@ export const expandSkillAssetDependencies = (
   return selected
 }
 
-export const expandSkillAssetDependenciesWithRemoteResolution = async (
+export const expandSkillAssetDependenciesWithRegistry = async (
   params: DependencyExpansionParams
 ) => {
   const selected: SkillAsset[] = []
@@ -261,16 +321,16 @@ export const expandSkillAssetDependenciesWithRemoteResolution = async (
     dependency: NormalizedSkillDependency,
     currentInstancePath?: string
   ) => {
-    const fetchKey = dependency.ref
+    const fetchKey = `${dependency.registry ?? ''}:${dependency.ref}`
     if (!fetchedDependencyRefs.has(fetchKey)) {
       fetchedDependencyRefs.add(fetchKey)
-      const installed = await installSkillsCliDependency({
+      const installed = await installRegistrySkillDependency({
         cwd: params.cwd,
         configs: params.configs,
         dependency
       })
       const definition = await parseFrontmatterSkill(installed.skillPath)
-      const dependencyAsset = createResolvedSkillAsset({
+      const dependencyAsset = createRegistrySkillAsset({
         cwd: params.cwd,
         definition
       })
@@ -335,13 +395,14 @@ export const expandSkillAssetDependenciesWithRemoteResolution = async (
       const dependencyAsset = await installDependencyAsset(dependency, asset.instancePath).catch((error: unknown) => {
         if (
           localOrBridgedDependency != null &&
-          dependency.source == null
+          dependency.source == null &&
+          dependency.registry == null
         ) {
           return localOrBridgedDependency
         }
         throw error
       }) ?? (
-        dependency.source == null
+        dependency.source == null && dependency.registry == null
           ? localOrBridgedDependency
           : undefined
       )