@vibe-forge/tsconfigs 0.8.0 → 0.9.0

package/dist/packages/types/src/config.d.ts

@@ -50,6 +50,7 @@ export interface NotificationConfig {
     events?: Partial<Record<NotificationTrigger, NotificationEventConfig>>;
 }
 export interface Config {
+    extend?: string | string[];
     baseDir?: string;
     adapters?: AdapterConfigMap;
     models?: Record<string, ModelMetadataConfig>;

package/dist/packages/workspace-assets/__tests__/adapter-asset-plan.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/packages/workspace-assets/__tests__/adapter-asset-plan.spec.js

@@ -0,0 +1,121 @@
+import { join } from 'node:path';
+import { describe, expect, it } from 'vitest';
+import { buildAdapterAssetPlan, resolvePromptAssetSelection, resolveWorkspaceAssetBundle } from '#~/index.js';
+import { createWorkspace, writeDocument } from './test-helpers';
+describe('buildAdapterAssetPlan', () => {
+    it('builds codex diagnostics for prompt, mcp, native hooks, and unsupported claude native plugins', async () => {
+        const workspace = await createWorkspace();
+        await writeDocument(join(workspace, '.ai.config.json'), JSON.stringify({
+            plugins: {
+                logger: {}
+            },
+            enabledPlugins: {
+                logger: true
+            },
+            mcpServers: {
+                docs: {
+                    command: 'npx',
+                    args: ['docs-server']
+                }
+            }
+        }));
+        await writeDocument(join(workspace, '.ai/skills/research/SKILL.md'), '---\ndescription: 检索资料\n---\n阅读 README.md');
+        const bundle = await resolveWorkspaceAssetBundle({
+            cwd: workspace,
+            configs: [{
+                    plugins: {
+                        logger: {}
+                    },
+                    enabledPlugins: {
+                        logger: true
+                    },
+                    mcpServers: {
+                        docs: {
+                            command: 'npx',
+                            args: ['docs-server']
+                        }
+                    }
+                }, undefined],
+            useDefaultVibeForgeMcpServer: false
+        });
+        const [, resolvedOptions] = await resolvePromptAssetSelection({
+            bundle,
+            type: undefined,
+            name: undefined,
+            input: {
+                skills: {
+                    include: ['research']
+                }
+            }
+        });
+        const plan = buildAdapterAssetPlan({
+            adapter: 'codex',
+            bundle,
+            options: {
+                promptAssetIds: resolvedOptions.promptAssetIds,
+                mcpServers: resolvedOptions.mcpServers,
+                skills: {
+                    include: ['research']
+                }
+            }
+        });
+        expect(plan.mcpServers).toHaveProperty('docs');
+        expect(plan.native.codexHooks?.supportedEvents).toEqual([
+            'SessionStart',
+            'UserPromptSubmit',
+            'PreToolUse',
+            'PostToolUse',
+            'Stop'
+        ]);
+        expect(plan.diagnostics).toEqual(expect.arrayContaining([
+            expect.objectContaining({
+                adapter: 'codex',
+                status: 'prompt'
+            }),
+            expect.objectContaining({
+                adapter: 'codex',
+                status: 'native',
+                assetId: 'hookPlugin:project:logger'
+            }),
+            expect.objectContaining({
+                adapter: 'codex',
+                status: 'translated',
+                assetId: 'mcpServer:project:docs'
+            }),
+            expect.objectContaining({
+                adapter: 'codex',
+                status: 'skipped',
+                assetId: 'nativePlugin:claude-code:logger'
+            })
+        ]));
+    });
+    it('builds opencode overlays for skills and native commands', async () => {
+        const workspace = await createWorkspace();
+        await writeDocument(join(workspace, '.ai/skills/research/SKILL.md'), '---\ndescription: 检索资料\n---\n阅读 README.md');
+        await writeDocument(join(workspace, '.ai/plugins/demo/opencode/commands/review.md'), '# review');
+        const bundle = await resolveWorkspaceAssetBundle({
+            cwd: workspace,
+            configs: [undefined, undefined],
+            useDefaultVibeForgeMcpServer: false
+        });
+        const plan = buildAdapterAssetPlan({
+            adapter: 'opencode',
+            bundle,
+            options: {
+                skills: {
+                    include: ['research']
+                }
+            }
+        });
+        expect(plan.overlays).toEqual(expect.arrayContaining([
+            expect.objectContaining({
+                kind: 'skill',
+                targetPath: 'skills/research'
+            }),
+            expect.objectContaining({
+                kind: 'command',
+                targetPath: 'commands/review.md'
+            })
+        ]));
+    });
+});

package/dist/packages/workspace-assets/__tests__/bundle.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/packages/workspace-assets/__tests__/bundle.spec.js

@@ -0,0 +1,61 @@
+import { join } from 'node:path';
+import process from 'node:process';
+import { describe, expect, it } from 'vitest';
+import { resolveWorkspaceAssetBundle } from '#~/index.js';
+import { createWorkspace, writeDocument } from './test-helpers';
+describe('resolveWorkspaceAssetBundle', () => {
+    it('treats enabledPlugins as a global asset switch', async () => {
+        const workspace = await createWorkspace();
+        await writeDocument(join(workspace, '.ai.config.json'), JSON.stringify({
+            plugins: {
+                logger: {}
+            },
+            enabledPlugins: {
+                logger: false,
+                demo: false
+            }
+        }));
+        await writeDocument(join(workspace, '.ai/plugins/demo/skills/research/SKILL.md'), '---\ndescription: 检索资料\n---\n阅读 README.md');
+        await writeDocument(join(workspace, '.ai/plugins/demo/rules/review.md'), '---\ndescription: 评审规则\n---\n必须检查风险');
+        await writeDocument(join(workspace, '.ai/plugins/demo/mcp/browser.json'), JSON.stringify({ command: 'npx', args: ['browser-server'] }));
+        await writeDocument(join(workspace, '.ai/plugins/demo/opencode/commands/review.md'), '# review');
+        const bundle = await resolveWorkspaceAssetBundle({
+            cwd: workspace,
+            configs: [{
+                    plugins: {
+                        logger: {}
+                    },
+                    enabledPlugins: {
+                        logger: false,
+                        demo: false
+                    }
+                }, undefined],
+            useDefaultVibeForgeMcpServer: false
+        });
+        expect(bundle.skills).toHaveLength(0);
+        expect(bundle.rules).toHaveLength(0);
+        expect(Object.keys(bundle.mcpServers)).toHaveLength(0);
+        expect(bundle.hookPlugins).toHaveLength(0);
+        expect(bundle.assets.some((asset) => asset.pluginId === 'demo' && asset.enabled))
+            .toBe(false);
+    });
+    it('adds the built-in Vibe Forge MCP server when enabled and omits it when disabled', async () => {
+        const workspace = await createWorkspace();
+        const enabledBundle = await resolveWorkspaceAssetBundle({
+            cwd: workspace,
+            configs: [undefined, undefined],
+            useDefaultVibeForgeMcpServer: true
+        });
+        expect(enabledBundle.mcpServers).toHaveProperty('vibe-forge');
+        expect(enabledBundle.mcpServers['vibe-forge']?.payload.config).toEqual(expect.objectContaining({
+            command: process.execPath,
+            args: [expect.stringMatching(/packages\/mcp\/cli\.js$/)]
+        }));
+        const disabledBundle = await resolveWorkspaceAssetBundle({
+            cwd: workspace,
+            configs: [undefined, undefined],
+            useDefaultVibeForgeMcpServer: false
+        });
+        expect(disabledBundle.mcpServers).not.toHaveProperty('vibe-forge');
+    });
+});

package/dist/packages/workspace-assets/__tests__/prompt-selection.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/packages/workspace-assets/__tests__/prompt-selection.spec.js

@@ -0,0 +1,29 @@
+import { join } from 'node:path';
+import { describe, expect, it } from 'vitest';
+import { resolvePromptAssetSelection, resolveWorkspaceAssetBundle } from '#~/index.js';
+import { createWorkspace, writeDocument } from './test-helpers';
+describe('resolvePromptAssetSelection', () => {
+    it('prefers project prompt assets over plugin assets with the same identifier', async () => {
+        const workspace = await createWorkspace();
+        await writeDocument(join(workspace, '.ai/specs/release.md'), '---\ndescription: 项目发布流程\n---\n执行项目发布');
+        await writeDocument(join(workspace, '.ai/plugins/demo/specs/release/index.md'), '---\ndescription: 插件发布流程\n---\n执行插件发布');
+        const bundle = await resolveWorkspaceAssetBundle({
+            cwd: workspace,
+            configs: [undefined, undefined],
+            useDefaultVibeForgeMcpServer: false
+        });
+        const [data, resolvedOptions] = await resolvePromptAssetSelection({
+            bundle,
+            type: 'spec',
+            name: 'release'
+        });
+        expect(data.targetBody).toContain('执行项目发布');
+        expect(data.targetBody).not.toContain('执行插件发布');
+        expect(data.specs).toHaveLength(1);
+        expect(resolvedOptions.systemPrompt).toContain('项目发布流程');
+        expect(resolvedOptions.systemPrompt).not.toContain('插件发布流程');
+        expect(resolvedOptions.promptAssetIds).toEqual(expect.arrayContaining([
+            'spec:.ai/specs/release.md'
+        ]));
+    });
+});

package/dist/packages/workspace-assets/__tests__/snapshot.d.ts

@@ -0,0 +1,15 @@
+import type { AdapterAssetPlan, Filter, PromptAssetResolution, WorkspaceAssetBundle } from '@vibe-forge/types';
+export declare const serializeWorkspaceAssetsSnapshot: (params: {
+    cwd: string;
+    bundle: WorkspaceAssetBundle;
+    selection: {
+        resolution: PromptAssetResolution;
+        options: {
+            systemPrompt?: string;
+            tools?: Filter;
+            mcpServers?: Filter;
+            promptAssetIds?: string[];
+        };
+    };
+    plans: AdapterAssetPlan[];
+}) => string;

package/dist/packages/workspace-assets/__tests__/snapshot.js

@@ -0,0 +1,203 @@
+import process from 'node:process';
+import { resolveDocumentName, resolveSpecIdentifier } from '@vibe-forge/utils';
+import { isOpenCodeOverlayAsset } from '#~/internal-types.js';
+const sortStrings = (values) => [...values].sort((left, right) => left.localeCompare(right));
+const isConfigNativePluginAsset = (asset) => !isOpenCodeOverlayAsset(asset);
+const sanitizeValue = (value, cwd) => (value
+    .replaceAll(cwd, '<workspace>')
+    .replaceAll(process.execPath, '<node-path>'));
+const normalizeValue = (value, cwd) => {
+    if (typeof value === 'string') {
+        return sanitizeValue(value, cwd);
+    }
+    if (Array.isArray(value)) {
+        return value.map(item => normalizeValue(item, cwd));
+    }
+    if (value != null && typeof value === 'object') {
+        return Object.fromEntries(Object.entries(value)
+            .sort(([left], [right]) => left.localeCompare(right))
+            .map(([key, entry]) => [key, normalizeValue(entry, cwd)]));
+    }
+    return value;
+};
+const sortFilter = (filter) => {
+    if (filter == null)
+        return undefined;
+    return {
+        include: filter.include == null ? undefined : sortStrings(filter.include),
+        exclude: filter.exclude == null ? undefined : sortStrings(filter.exclude)
+    };
+};
+const resolveDefinitionIdentifier = (kind, definition) => {
+    if (kind === 'spec') {
+        return resolveSpecIdentifier(definition.path, definition.attributes.name);
+    }
+    if (kind === 'entity') {
+        return resolveDocumentName(definition.path, definition.attributes.name, ['readme.md', 'index.json']);
+    }
+    if (kind === 'skill') {
+        return resolveDocumentName(definition.path, definition.attributes.name, ['skill.md']);
+    }
+    return resolveDocumentName(definition.path, definition.attributes.name);
+};
+const summarizeDefinition = (kind, definition, cwd) => ({
+    identifier: resolveDefinitionIdentifier(kind, definition),
+    path: sanitizeValue(definition.path, cwd),
+    attributes: normalizeValue(definition.attributes, cwd),
+    body: definition.body.trim()
+});
+const summarizeDocumentAsset = (asset, cwd) => ({
+    id: asset.id,
+    kind: asset.kind,
+    origin: asset.origin,
+    scope: asset.scope,
+    pluginId: asset.pluginId,
+    enabled: asset.enabled,
+    targets: sortStrings(asset.targets),
+    definition: summarizeDefinition(asset.kind, asset.payload.definition, cwd)
+});
+const summarizeMcpServer = (asset, cwd) => ({
+    id: asset.id,
+    origin: asset.origin,
+    scope: asset.scope,
+    pluginId: asset.pluginId,
+    enabled: asset.enabled,
+    targets: sortStrings(asset.targets),
+    name: asset.payload.name,
+    config: normalizeValue(asset.payload.config, cwd)
+});
+const summarizeHookPlugin = (asset, cwd) => ({
+    id: asset.id,
+    origin: asset.origin,
+    scope: asset.scope,
+    pluginId: asset.pluginId,
+    enabled: asset.enabled,
+    targets: sortStrings(asset.targets),
+    packageName: asset.payload.packageName,
+    config: normalizeValue(asset.payload.config, cwd)
+});
+const summarizeNativePlugin = (asset, cwd) => {
+    if (isOpenCodeOverlayAsset(asset)) {
+        return {
+            id: asset.id,
+            kind: asset.kind,
+            origin: asset.origin,
+            scope: asset.scope,
+            pluginId: asset.pluginId,
+            enabled: asset.enabled,
+            targets: sortStrings(asset.targets),
+            entryName: asset.payload.entryName,
+            sourcePath: sanitizeValue(asset.payload.sourcePath, cwd),
+            targetSubpath: asset.payload.targetSubpath
+        };
+    }
+    return {
+        id: asset.id,
+        kind: asset.kind,
+        origin: asset.origin,
+        scope: asset.scope,
+        pluginId: asset.pluginId,
+        enabled: asset.enabled,
+        targets: sortStrings(asset.targets),
+        name: isConfigNativePluginAsset(asset) ? asset.payload.name : undefined
+    };
+};
+const summarizeOverlayAsset = (asset, cwd) => {
+    if (!isOpenCodeOverlayAsset(asset)) {
+        return summarizeNativePlugin(asset, cwd);
+    }
+    return {
+        id: asset.id,
+        kind: asset.kind,
+        origin: asset.origin,
+        scope: asset.scope,
+        pluginId: asset.pluginId,
+        enabled: asset.enabled,
+        targets: sortStrings(asset.targets),
+        entryName: asset.payload.entryName,
+        sourcePath: sanitizeValue(asset.payload.sourcePath, cwd),
+        targetSubpath: asset.payload.targetSubpath
+    };
+};
+const summarizeDiagnostics = (diagnostics) => ([...diagnostics]
+    .sort((left, right) => {
+    const assetIdDiff = left.assetId.localeCompare(right.assetId);
+    if (assetIdDiff !== 0)
+        return assetIdDiff;
+    return left.status.localeCompare(right.status);
+})
+    .map(diagnostic => ({
+    assetId: diagnostic.assetId,
+    adapter: diagnostic.adapter,
+    status: diagnostic.status,
+    reason: diagnostic.reason
+})));
+const summarizePlan = (plan, cwd) => ({
+    adapter: plan.adapter,
+    mcpServers: normalizeValue(plan.mcpServers, cwd),
+    overlays: [...plan.overlays]
+        .sort((left, right) => left.assetId.localeCompare(right.assetId))
+        .map(entry => ({
+        assetId: entry.assetId,
+        kind: entry.kind,
+        sourcePath: sanitizeValue(entry.sourcePath, cwd),
+        targetPath: entry.targetPath
+    })),
+    native: normalizeValue(plan.native, cwd),
+    diagnostics: summarizeDiagnostics(plan.diagnostics)
+});
+const summarizeSelection = (resolution, options, cwd) => ({
+    resolution: {
+        rules: resolution.rules.map(rule => summarizeDefinition('rule', rule, cwd)),
+        targetSkills: resolution.targetSkills.map(skill => summarizeDefinition('skill', skill, cwd)),
+        entities: resolution.entities.map(entity => summarizeDefinition('entity', entity, cwd)),
+        skills: resolution.skills.map(skill => summarizeDefinition('skill', skill, cwd)),
+        specs: resolution.specs.map(spec => summarizeDefinition('spec', spec, cwd)),
+        targetBody: resolution.targetBody.trim(),
+        promptAssetIds: sortStrings(resolution.promptAssetIds)
+    },
+    options: {
+        systemPrompt: options.systemPrompt?.trim(),
+        tools: sortFilter(options.tools),
+        mcpServers: sortFilter(options.mcpServers),
+        promptAssetIds: options.promptAssetIds == null ? undefined : sortStrings(options.promptAssetIds)
+    }
+});
+export const serializeWorkspaceAssetsSnapshot = (params) => {
+    const { bundle, cwd } = params;
+    const overlayAssets = bundle.assets.filter((asset) => (asset.kind === 'agent' ||
+        asset.kind === 'command' ||
+        asset.kind === 'mode' ||
+        (asset.kind === 'nativePlugin' && isOpenCodeOverlayAsset(asset))));
+    const claudeNativePlugins = bundle.assets.filter((asset) => (asset.kind === 'nativePlugin' && !isOpenCodeOverlayAsset(asset)));
+    const snapshot = {
+        bundle: {
+            cwd: '<workspace>',
+            enabledPlugins: normalizeValue(bundle.enabledPlugins, cwd),
+            extraKnownMarketplaces: normalizeValue(bundle.extraKnownMarketplaces, cwd),
+            defaultIncludeMcpServers: sortStrings(bundle.defaultIncludeMcpServers),
+            defaultExcludeMcpServers: sortStrings(bundle.defaultExcludeMcpServers),
+            rules: bundle.rules.map(rule => summarizeDocumentAsset(rule, cwd)),
+            specs: bundle.specs.map(spec => summarizeDocumentAsset(spec, cwd)),
+            entities: bundle.entities.map(entity => summarizeDocumentAsset(entity, cwd)),
+            skills: bundle.skills.map(skill => summarizeDocumentAsset(skill, cwd)),
+            mcpServers: Object.values(bundle.mcpServers)
+                .sort((left, right) => left.payload.name.localeCompare(right.payload.name))
+                .map(server => summarizeMcpServer(server, cwd)),
+            hookPlugins: bundle.hookPlugins
+                .sort((left, right) => left.id.localeCompare(right.id))
+                .map(plugin => summarizeHookPlugin(plugin, cwd)),
+            claudeNativePlugins: claudeNativePlugins
+                .sort((left, right) => left.id.localeCompare(right.id))
+                .map(asset => summarizeNativePlugin(asset, cwd)),
+            opencodeOverlayAssets: overlayAssets
+                .sort((left, right) => left.id.localeCompare(right.id))
+                .map(asset => summarizeOverlayAsset(asset, cwd))
+        },
+        selection: summarizeSelection(params.selection.resolution, params.selection.options, cwd),
+        plans: Object.fromEntries([...params.plans]
+            .sort((left, right) => left.adapter.localeCompare(right.adapter))
+            .map(plan => [plan.adapter, summarizePlan(plan, cwd)]))
+    };
+    return `${JSON.stringify(snapshot, null, 2)}\n`;
+};

package/dist/packages/workspace-assets/__tests__/test-helpers.d.ts

@@ -0,0 +1,2 @@
+export declare const createWorkspace: () => Promise<string>;
+export declare const writeDocument: (filePath: string, content: string) => Promise<void>;

package/dist/packages/workspace-assets/__tests__/test-helpers.js

@@ -0,0 +1,17 @@
+import { mkdir, mkdtemp, rm, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { dirname, join } from 'node:path';
+import { afterEach } from 'vitest';
+const tempDirs = [];
+export const createWorkspace = async () => {
+    const dir = await mkdtemp(join(tmpdir(), 'workspace-assets-'));
+    tempDirs.push(dir);
+    return dir;
+};
+export const writeDocument = async (filePath, content) => {
+    await mkdir(dirname(filePath), { recursive: true });
+    await writeFile(filePath, content);
+};
+afterEach(async () => {
+    await Promise.all(tempDirs.splice(0).map(dir => rm(dir, { recursive: true, force: true })));
+});

package/dist/packages/workspace-assets/__tests__/workspace-assets.snapshot.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/packages/workspace-assets/__tests__/workspace-assets.snapshot.spec.js

@@ -0,0 +1,172 @@
+import { join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { describe, expect, it } from 'vitest';
+import { buildAdapterAssetPlan, resolvePromptAssetSelection, resolveWorkspaceAssetBundle } from '#~/index.js';
+import { serializeWorkspaceAssetsSnapshot } from './snapshot';
+import { createWorkspace, writeDocument } from './test-helpers';
+const resolveSnapshotPath = (name) => (fileURLToPath(new URL(`./__snapshots__/${name}.snapshot.json`, import.meta.url)));
+describe('workspace assets snapshots', () => {
+    it('projects a rich workspace bundle, prompt selection, and adapter plans', async () => {
+        const workspace = await createWorkspace();
+        const projectConfig = {
+            plugins: {
+                logger: {
+                    level: 'info'
+                }
+            },
+            enabledPlugins: {
+                logger: true,
+                demo: true,
+                legacy: false,
+                telemetry: true
+            },
+            mcpServers: {
+                docs: {
+                    command: 'npx',
+                    args: ['docs-server']
+                }
+            },
+            defaultIncludeMcpServers: ['docs', 'browser'],
+            extraKnownMarketplaces: {
+                internal: {
+                    source: {
+                        source: 'git',
+                        url: 'https://plugins.internal.example.com'
+                    }
+                }
+            }
+        };
+        const userConfig = {
+            plugins: {
+                telemetry: {
+                    mode: 'summary'
+                }
+            },
+            enabledPlugins: {
+                telemetry: true
+            },
+            mcpServers: {
+                notes: {
+                    command: 'node',
+                    args: ['tools/notes-mcp.js']
+                }
+            },
+            defaultExcludeMcpServers: ['notes']
+        };
+        await writeDocument(join(workspace, '.ai/rules/review.md'), [
+            '---',
+            'description: 项目评审规则',
+            'always: true',
+            '---',
+            '必须检查发布改动的回归风险。'
+        ].join('\n'));
+        await writeDocument(join(workspace, '.ai/plugins/demo/rules/review.md'), [
+            '---',
+            'description: 插件评审规则',
+            'always: true',
+            '---',
+            '这是插件内的 review 规则，不应覆盖项目规则。'
+        ].join('\n'));
+        await writeDocument(join(workspace, '.ai/plugins/demo/rules/security.md'), [
+            '---',
+            'description: 插件安全规则',
+            '---',
+            '上线前要检查权限与密钥暴露。'
+        ].join('\n'));
+        await writeDocument(join(workspace, '.ai/specs/release/index.md'), [
+            '---',
+            'description: 正式发布流程',
+            'rules:',
+            '  - .ai/rules/review.md',
+            'skills:',
+            '  - research',
+            'mcpServers:',
+            '  include:',
+            '    - docs',
+            '    - browser',
+            '  exclude:',
+            '    - browser',
+            'tools:',
+            '  include:',
+            '    - Read',
+            '    - Edit',
+            '---',
+            '执行正式发布，并整理变更摘要。'
+        ].join('\n'));
+        await writeDocument(join(workspace, '.ai/plugins/demo/specs/release/index.md'), [
+            '---',
+            'description: 插件发布流程',
+            '---',
+            '插件 release 不应覆盖项目 release。'
+        ].join('\n'));
+        await writeDocument(join(workspace, '.ai/entities/architect/README.md'), [
+            '---',
+            'description: 负责拆解方案的实体',
+            '---',
+            '把发布任务拆解成执行步骤。'
+        ].join('\n'));
+        await writeDocument(join(workspace, '.ai/skills/research/SKILL.md'), [
+            '---',
+            'description: 检索资料',
+            '---',
+            '先阅读 README.md，再补充结论。'
+        ].join('\n'));
+        await writeDocument(join(workspace, '.ai/plugins/demo/skills/research/SKILL.md'), [
+            '---',
+            'description: 插件 research',
+            '---',
+            '插件 research 不应覆盖项目 skill。'
+        ].join('\n'));
+        await writeDocument(join(workspace, '.ai/plugins/demo/skills/audit/SKILL.md'), [
+            '---',
+            'description: 审计输出',
+            '---',
+            '检查最终输出是否覆盖风险项。'
+        ].join('\n'));
+        await writeDocument(join(workspace, '.ai/plugins/demo/mcp/browser.json'), JSON.stringify({
+            name: 'browser',
+            command: 'npx',
+            args: ['browser-mcp']
+        }, null, 2));
+        await writeDocument(join(workspace, '.ai/plugins/demo/opencode/plugins/demo-plugin.js'), 'export default {};\n');
+        await writeDocument(join(workspace, '.ai/plugins/demo/opencode/agents/release-helper.md'), '# release-helper\n');
+        await writeDocument(join(workspace, '.ai/plugins/demo/opencode/commands/review.md'), '# review\n');
+        await writeDocument(join(workspace, '.ai/plugins/demo/opencode/modes/strict.md'), '# strict\n');
+        const bundle = await resolveWorkspaceAssetBundle({
+            cwd: workspace,
+            configs: [projectConfig, userConfig],
+            useDefaultVibeForgeMcpServer: false
+        });
+        const [resolution, options] = await resolvePromptAssetSelection({
+            bundle,
+            type: 'spec',
+            name: 'release',
+            input: {
+                skills: {
+                    include: ['research']
+                }
+            }
+        });
+        const adapters = ['claude-code', 'codex', 'opencode'];
+        const plans = adapters.map(adapter => (buildAdapterAssetPlan({
+            adapter,
+            bundle,
+            options: {
+                promptAssetIds: options.promptAssetIds,
+                mcpServers: options.mcpServers,
+                skills: {
+                    include: ['research']
+                }
+            }
+        })));
+        await expect(serializeWorkspaceAssetsSnapshot({
+            cwd: workspace,
+            bundle,
+            selection: {
+                resolution,
+                options
+            },
+            plans
+        })).toMatchFileSnapshot(resolveSnapshotPath('workspace-assets-rich'));
+    });
+});

package/package.json

@@ -1,5 +1,5 @@
 {
   "name": "@vibe-forge/tsconfigs",
-  "version": "0.8.0",
+  "version": "0.9.0",
   "description": "TSConfig for Vibe Forge"
 }