@vibe-forge/tsconfigs 0.7.2 → 0.9.0

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

@@ -0,0 +1,213 @@
+import { mkdir, mkdtemp, rm, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { dirname, join } from 'node:path';
+import process from 'node:process';
+import { afterEach, describe, expect, it } from 'vitest';
+import { buildAdapterAssetPlan, resolvePromptAssetSelection, resolveWorkspaceAssetBundle } from '#~/index.js';
+const tempDirs = [];
+const createWorkspace = async () => {
+    const dir = await mkdtemp(join(tmpdir(), 'workspace-assets-'));
+    tempDirs.push(dir);
+    return dir;
+};
+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 })));
+});
+describe('workspace assets', () => {
+    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'
+        ]));
+    });
+    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('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'
+            })
+        ]));
+    });
+    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/src/adapter-asset-plan.d.ts

@@ -0,0 +1,10 @@
+import type { AdapterAssetPlan, WorkspaceAssetAdapter, WorkspaceAssetBundle, WorkspaceMcpSelection, WorkspaceSkillSelection } from '@vibe-forge/types';
+export declare function buildAdapterAssetPlan(params: {
+    adapter: WorkspaceAssetAdapter;
+    bundle: WorkspaceAssetBundle;
+    options: {
+        mcpServers?: WorkspaceMcpSelection;
+        skills?: WorkspaceSkillSelection;
+        promptAssetIds?: string[];
+    };
+}): AdapterAssetPlan;

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

@@ -0,0 +1,143 @@
+import { basename, dirname } from 'node:path';
+import { filterSkillAssets } from './document-assets';
+import { isOpenCodeOverlayAsset } from './internal-types';
+const resolveMcpServerSelection = (bundle, selection) => {
+    const include = selection?.include ?? (bundle.defaultIncludeMcpServers.length > 0 ? bundle.defaultIncludeMcpServers : undefined);
+    const exclude = selection?.exclude ?? (bundle.defaultExcludeMcpServers.length > 0 ? bundle.defaultExcludeMcpServers : undefined);
+    return {
+        include,
+        exclude
+    };
+};
+export function buildAdapterAssetPlan(params) {
+    const diagnostics = [];
+    const promptAssetIdSet = new Set(params.options.promptAssetIds ?? []);
+    const mcpSelection = resolveMcpServerSelection(params.bundle, params.options.mcpServers);
+    const selectedMcpServerNames = Object.keys(params.bundle.mcpServers).filter((name) => {
+        if (mcpSelection.include != null && !mcpSelection.include.includes(name))
+            return false;
+        if (mcpSelection.exclude?.includes(name))
+            return false;
+        return true;
+    });
+    const mcpServers = Object.fromEntries(selectedMcpServerNames.map((name) => [name, params.bundle.mcpServers[name].payload.config]));
+    for (const assetId of promptAssetIdSet) {
+        diagnostics.push({
+            assetId,
+            adapter: params.adapter,
+            status: 'prompt',
+            reason: 'Mapped into the generated system prompt.'
+        });
+    }
+    for (const name of selectedMcpServerNames) {
+        diagnostics.push({
+            assetId: params.bundle.mcpServers[name].id,
+            adapter: params.adapter,
+            status: params.adapter === 'claude-code' ? 'native' : 'translated',
+            reason: params.adapter === 'claude-code'
+                ? 'Mapped into native MCP settings.'
+                : 'Translated into adapter-specific MCP configuration.'
+        });
+    }
+    for (const hookPlugin of params.bundle.hookPlugins) {
+        const nativeHookReason = params.adapter === 'claude-code'
+            ? 'Mapped into the isolated Claude Code native hooks bridge under .ai/.mock/.claude/settings.json.'
+            : params.adapter === 'codex'
+                ? 'Mapped into the isolated Codex native hooks bridge for SessionStart, UserPromptSubmit, PreToolUse, PostToolUse, and Stop.'
+                : 'Mapped into the isolated OpenCode native hook plugin bridge under .ai/.mock/.config/opencode/plugins.';
+        diagnostics.push({
+            assetId: hookPlugin.id,
+            adapter: params.adapter,
+            status: 'native',
+            reason: nativeHookReason
+        });
+    }
+    const overlays = [];
+    if (params.adapter === 'opencode') {
+        const skillAssets = filterSkillAssets(params.bundle.skills, params.options.skills);
+        for (const skillAsset of skillAssets) {
+            overlays.push({
+                assetId: skillAsset.id,
+                kind: 'skill',
+                sourcePath: dirname(skillAsset.payload.definition.path),
+                targetPath: `skills/${basename(dirname(skillAsset.payload.definition.path))}`
+            });
+            diagnostics.push({
+                assetId: skillAsset.id,
+                adapter: 'opencode',
+                status: 'native',
+                reason: 'Mirrored into OPENCODE_CONFIG_DIR as a native skill.'
+            });
+        }
+        for (const asset of params.bundle.assets) {
+            if (!isOpenCodeOverlayAsset(asset))
+                continue;
+            if (!asset.targets.includes('opencode'))
+                continue;
+            overlays.push({
+                assetId: asset.id,
+                kind: asset.kind,
+                sourcePath: asset.payload.sourcePath,
+                targetPath: asset.payload.targetSubpath
+            });
+            diagnostics.push({
+                assetId: asset.id,
+                adapter: 'opencode',
+                status: 'native',
+                reason: 'Mirrored into OPENCODE_CONFIG_DIR as a native OpenCode asset.'
+            });
+        }
+    }
+    if (params.adapter !== 'claude-code') {
+        for (const asset of params.bundle.assets) {
+            if (asset.kind !== 'nativePlugin' || !asset.enabled || !asset.targets.includes('claude-code'))
+                continue;
+            diagnostics.push({
+                assetId: asset.id,
+                adapter: params.adapter,
+                status: 'skipped',
+                reason: 'Claude marketplace plugin settings do not have a native mapping for this adapter.'
+            });
+        }
+    }
+    if (params.adapter === 'codex') {
+        for (const asset of params.bundle.assets) {
+            if (!['nativePlugin', 'agent', 'command', 'mode'].includes(asset.kind))
+                continue;
+            if (asset.targets.includes('codex'))
+                continue;
+            if (asset.kind === 'nativePlugin' && asset.targets.includes('claude-code'))
+                continue;
+            diagnostics.push({
+                assetId: asset.id,
+                adapter: 'codex',
+                status: 'skipped',
+                reason: 'No stable native Codex mapping exists for this asset kind in V1.'
+            });
+        }
+    }
+    return {
+        adapter: params.adapter,
+        diagnostics,
+        mcpServers,
+        overlays,
+        native: params.adapter === 'claude-code'
+            ? {
+                enabledPlugins: params.bundle.enabledPlugins,
+                extraKnownMarketplaces: params.bundle.extraKnownMarketplaces
+            }
+            : params.adapter === 'codex' && params.bundle.hookPlugins.length > 0
+                ? {
+                    codexHooks: {
+                        supportedEvents: [
+                            'SessionStart',
+                            'UserPromptSubmit',
+                            'PreToolUse',
+                            'PostToolUse',
+                            'Stop'
+                        ]
+                    }
+                }
+                : {}
+    };
+}

package/dist/packages/workspace-assets/src/bundle.d.ts

@@ -0,0 +1,6 @@
+import type { Config, WorkspaceAssetBundle } from '@vibe-forge/types';
+export declare function resolveWorkspaceAssetBundle(params: {
+    cwd: string;
+    configs?: [Config?, Config?];
+    useDefaultVibeForgeMcpServer?: boolean;
+}): Promise<WorkspaceAssetBundle>;

package/dist/packages/workspace-assets/src/bundle.js

@@ -0,0 +1,110 @@
+import process from 'node:process';
+import { buildConfigJsonVariables, DEFAULT_VIBE_FORGE_MCP_SERVER_NAME, loadConfig, resolveDefaultVibeForgeMcpServerConfig } from '@vibe-forge/config';
+import { DefinitionLoader } from '@vibe-forge/definition-loader';
+import { resolveDocumentName, resolveSpecIdentifier } from '@vibe-forge/utils';
+import { createDocumentAsset, dedupeDocumentAssets, dedupeDocumentAssetsByIdentifier, resolveRuleIdentifier, resolveSkillIdentifier } from './document-assets';
+import { mergeRecord, uniqueValues } from './helpers';
+import { createClaudeNativePluginAssets, createHookPluginAssets, loadOpenCodeOverlayAssets, loadPluginMcpAssets } from './plugin-assets';
+const readConfigForWorkspace = async (cwd) => {
+    return loadConfig({
+        cwd,
+        jsonVariables: buildConfigJsonVariables(cwd, process.env)
+    });
+};
+export async function resolveWorkspaceAssetBundle(params) {
+    const [config, userConfig] = params.configs ?? await readConfigForWorkspace(params.cwd);
+    const enabledPlugins = mergeRecord(config?.enabledPlugins, userConfig?.enabledPlugins);
+    const extraKnownMarketplaces = mergeRecord(config?.extraKnownMarketplaces, userConfig?.extraKnownMarketplaces);
+    const loader = new DefinitionLoader(params.cwd);
+    const [rawRules, rawSpecs, rawEntities, rawSkills, pluginMcpAssets, openCodeOverlayAssets] = await Promise.all([
+        loader.loadDefaultRules(),
+        loader.loadDefaultSpecs(),
+        loader.loadDefaultEntities(),
+        loader.loadDefaultSkills(),
+        loadPluginMcpAssets(params.cwd, enabledPlugins),
+        loadOpenCodeOverlayAssets(params.cwd, enabledPlugins)
+    ]);
+    const assets = [];
+    const rules = dedupeDocumentAssetsByIdentifier(dedupeDocumentAssets(rawRules.map((definition) => createDocumentAsset({ cwd: params.cwd, kind: 'rule', definition })), enabledPlugins), asset => resolveRuleIdentifier(asset.payload.definition.path, asset.payload.definition.attributes.name));
+    const specs = dedupeDocumentAssetsByIdentifier(dedupeDocumentAssets(rawSpecs.map((definition) => createDocumentAsset({ cwd: params.cwd, kind: 'spec', definition })), enabledPlugins), asset => resolveSpecIdentifier(asset.payload.definition.path, asset.payload.definition.attributes.name));
+    const entities = dedupeDocumentAssetsByIdentifier(dedupeDocumentAssets(rawEntities.map((definition) => createDocumentAsset({ cwd: params.cwd, kind: 'entity', definition })), enabledPlugins), asset => resolveDocumentName(asset.payload.definition.path, asset.payload.definition.attributes.name, ['readme.md', 'index.json']));
+    const skills = dedupeDocumentAssetsByIdentifier(dedupeDocumentAssets(rawSkills.map((definition) => createDocumentAsset({ cwd: params.cwd, kind: 'skill', definition })), enabledPlugins), asset => resolveSkillIdentifier(asset.payload.definition.path, asset.payload.definition.attributes.name));
+    assets.push(...rules, ...specs, ...entities, ...skills);
+    const mcpServers = new Map();
+    if (params.useDefaultVibeForgeMcpServer !== false) {
+        const defaultVibeForgeMcpServer = resolveDefaultVibeForgeMcpServerConfig();
+        if (defaultVibeForgeMcpServer != null) {
+            mcpServers.set(DEFAULT_VIBE_FORGE_MCP_SERVER_NAME, {
+                id: `mcpServer:fallback:${DEFAULT_VIBE_FORGE_MCP_SERVER_NAME}`,
+                kind: 'mcpServer',
+                origin: 'fallback',
+                scope: 'adapter',
+                enabled: true,
+                targets: ['claude-code', 'codex', 'opencode'],
+                payload: {
+                    name: DEFAULT_VIBE_FORGE_MCP_SERVER_NAME,
+                    config: defaultVibeForgeMcpServer
+                }
+            });
+        }
+    }
+    const userMcpServers = userConfig?.mcpServers ?? {};
+    for (const [name, serverConfig] of Object.entries(userMcpServers)) {
+        mcpServers.set(name, {
+            id: `mcpServer:user:${name}`,
+            kind: 'mcpServer',
+            origin: 'config',
+            scope: 'user',
+            enabled: true,
+            targets: ['claude-code', 'codex', 'opencode'],
+            payload: {
+                name,
+                config: serverConfig
+            }
+        });
+    }
+    for (const asset of pluginMcpAssets) {
+        mcpServers.set(asset.payload.name, asset);
+    }
+    for (const [name, serverConfig] of Object.entries(config?.mcpServers ?? {})) {
+        mcpServers.set(name, {
+            id: `mcpServer:project:${name}`,
+            kind: 'mcpServer',
+            origin: 'config',
+            scope: 'project',
+            enabled: true,
+            targets: ['claude-code', 'codex', 'opencode'],
+            payload: {
+                name,
+                config: serverConfig
+            }
+        });
+    }
+    assets.push(...mcpServers.values());
+    const hookPlugins = [
+        ...createHookPluginAssets(userConfig?.plugins, enabledPlugins, 'user'),
+        ...createHookPluginAssets(config?.plugins, enabledPlugins, 'project')
+    ];
+    const claudeNativePlugins = createClaudeNativePluginAssets(enabledPlugins);
+    assets.push(...hookPlugins, ...claudeNativePlugins, ...openCodeOverlayAssets);
+    return {
+        cwd: params.cwd,
+        assets,
+        rules,
+        specs,
+        entities,
+        skills,
+        mcpServers: Object.fromEntries(mcpServers.entries()),
+        hookPlugins,
+        enabledPlugins,
+        extraKnownMarketplaces,
+        defaultIncludeMcpServers: uniqueValues([
+            ...(config?.defaultIncludeMcpServers ?? []),
+            ...(userConfig?.defaultIncludeMcpServers ?? [])
+        ]),
+        defaultExcludeMcpServers: uniqueValues([
+            ...(config?.defaultExcludeMcpServers ?? []),
+            ...(userConfig?.defaultExcludeMcpServers ?? [])
+        ])
+    };
+}

package/dist/packages/workspace-assets/src/document-assets.d.ts

@@ -0,0 +1,55 @@
+import type { RuleReference, SkillSelection, WorkspaceAsset, WorkspaceAssetAdapter, WorkspaceAssetKind, WorkspaceAssetBundle, WorkspaceSkillSelection } from '@vibe-forge/types';
+import type { WorkspaceDocumentAsset, WorkspaceDocumentPayload } from './internal-types';
+export declare const createDocumentAsset: <TKind extends Extract<WorkspaceAssetKind, "rule" | "spec" | "entity" | "skill">, TDefinition>(params: {
+    cwd: string;
+    kind: TKind;
+    definition: TDefinition & {
+        path: string;
+    };
+    targets?: WorkspaceAssetAdapter[];
+}) => Extract<WorkspaceAsset, {
+    kind: TKind;
+}>;
+export declare const dedupeDocumentAssets: <TAsset extends Extract<WorkspaceAsset, {
+    kind: "rule" | "spec" | "entity" | "skill";
+}>>(assets: TAsset[], enabledPlugins: Record<string, boolean>) => TAsset[];
+export declare const dedupeDocumentAssetsByIdentifier: <TAsset extends Extract<WorkspaceAsset, {
+    kind: "rule" | "spec" | "entity" | "skill";
+}>>(assets: TAsset[], resolveIdentifier: (asset: TAsset) => string) => TAsset[];
+export declare const resolveRuleIdentifier: (path: string, explicitName?: string) => string;
+export declare const resolveSkillIdentifier: (path: string, explicitName?: string) => string;
+export declare const pickSpecAsset: (bundle: WorkspaceAssetBundle, name: string) => Extract<WorkspaceAsset, {
+    kind: "spec";
+}> | undefined;
+export declare const pickEntityAsset: (bundle: WorkspaceAssetBundle, name: string) => Extract<WorkspaceAsset, {
+    kind: "entity";
+}> | undefined;
+export declare const filterSkillAssets: (skills: Array<Extract<WorkspaceAsset, {
+    kind: "skill";
+}>>, selection?: WorkspaceSkillSelection) => Array<Extract<WorkspaceAsset, {
+    kind: "skill";
+}>>;
+export declare const dedupeSkillAssets: (skills: Array<Extract<WorkspaceAsset, {
+    kind: "skill";
+}>>) => Array<Extract<WorkspaceAsset, {
+    kind: "skill";
+}>>;
+export declare const resolveRulePatterns: (rules: RuleReference[]) => string[];
+export declare const resolveIncludedSkillNames: (selection: string[] | SkillSelection) => string[];
+export declare const resolveExcludedSkillNames: (selection: string[] | SkillSelection) => string[];
+export declare const resolveSelectedRuleAssets: (bundle: WorkspaceAssetBundle, patterns: string[]) => Promise<Array<Extract<WorkspaceAsset, {
+    kind: "rule";
+}>>>;
+export declare const toDocumentDefinitions: <TDefinition>(assets: Array<WorkspaceDocumentAsset<TDefinition>>) => ((import("@vibe-forge/types").Definition<import("@vibe-forge/types").Rule> & TDefinition & {
+    path: string;
+}) | (import("@vibe-forge/types").Definition<import("@vibe-forge/types").Spec> & TDefinition & {
+    path: string;
+}) | (import("@vibe-forge/types").Definition<import("@vibe-forge/types").Entity> & TDefinition & {
+    path: string;
+}) | (import("@vibe-forge/types").Definition<import("@vibe-forge/types").Skill> & TDefinition & {
+    path: string;
+}))[];
+export declare const toPromptAssetIds: (assets: Array<{
+    id: string;
+}>) => string[];
+export type { WorkspaceDocumentAsset, WorkspaceDocumentPayload };

package/dist/packages/workspace-assets/src/document-assets.js

@@ -0,0 +1,103 @@
+import { basename, dirname } from 'node:path';
+import { glob } from 'fast-glob';
+import { normalizePath, resolveDocumentName, resolveRelativePath, resolveSpecIdentifier } from '@vibe-forge/utils';
+import { assetOriginPriority, isPluginEnabled, resolvePluginIdFromPath, toAssetScope } from './helpers';
+const isLocalRuleReference = (rule) => (rule != null &&
+    typeof rule === 'object' &&
+    'path' in rule &&
+    typeof rule.path === 'string');
+export const createDocumentAsset = (params) => {
+    const pluginId = resolvePluginIdFromPath(params.cwd, params.definition.path);
+    const origin = pluginId == null ? 'project' : 'plugin';
+    return {
+        id: `${params.kind}:${resolveRelativePath(params.cwd, params.definition.path)}`,
+        kind: params.kind,
+        pluginId,
+        origin,
+        scope: toAssetScope(origin),
+        enabled: true,
+        targets: params.targets ?? ['claude-code', 'codex', 'opencode'],
+        payload: {
+            definition: params.definition,
+            sourcePath: params.definition.path
+        }
+    };
+};
+export const dedupeDocumentAssets = (assets, enabledPlugins) => assets.filter((asset) => isPluginEnabled(enabledPlugins, asset.pluginId));
+const compareDocumentAssetPriority = (left, right) => {
+    const originDiff = assetOriginPriority[left.origin] - assetOriginPriority[right.origin];
+    if (originDiff !== 0)
+        return originDiff;
+    return left.payload.definition.path.localeCompare(right.payload.definition.path);
+};
+export const dedupeDocumentAssetsByIdentifier = (assets, resolveIdentifier) => {
+    const selected = new Map();
+    for (const asset of [...assets].sort(compareDocumentAssetPriority)) {
+        const identifier = resolveIdentifier(asset);
+        if (!selected.has(identifier))
+            selected.set(identifier, asset);
+    }
+    return Array.from(selected.values()).sort(compareDocumentAssetPriority);
+};
+export const resolveRuleIdentifier = (path, explicitName) => resolveDocumentName(path, explicitName);
+export const resolveSkillIdentifier = (path, explicitName) => resolveDocumentName(path, explicitName, ['skill.md']);
+export const pickSpecAsset = (bundle, name) => {
+    const assets = bundle.specs.filter((asset) => {
+        const definition = asset.payload.definition;
+        return resolveSpecIdentifier(definition.path, definition.attributes.name) === name;
+    });
+    return assets.find(asset => asset.origin === 'project') ?? assets[0];
+};
+export const pickEntityAsset = (bundle, name) => {
+    const assets = bundle.entities.filter((asset) => {
+        const definition = asset.payload.definition;
+        const identifier = resolveDocumentName(definition.path, definition.attributes.name, ['readme.md', 'index.json']);
+        return identifier === name;
+    });
+    return assets.find(asset => asset.origin === 'project') ?? assets[0];
+};
+export const filterSkillAssets = (skills, selection) => {
+    if (selection == null)
+        return skills;
+    const include = selection.include != null && selection.include.length > 0
+        ? new Set(selection.include)
+        : undefined;
+    const exclude = new Set(selection.exclude ?? []);
+    return skills.filter((skill) => {
+        const name = basename(dirname(skill.payload.definition.path));
+        return (include == null || include.has(name)) && !exclude.has(name);
+    });
+};
+export const dedupeSkillAssets = (skills) => {
+    const seen = new Set();
+    return skills.filter((skill) => {
+        if (seen.has(skill.payload.definition.path))
+            return false;
+        seen.add(skill.payload.definition.path);
+        return true;
+    });
+};
+export const resolveRulePatterns = (rules) => (rules.flatMap((rule) => {
+    if (typeof rule === 'string')
+        return [rule];
+    if (isLocalRuleReference(rule))
+        return [rule.path];
+    return [];
+}));
+export const resolveIncludedSkillNames = (selection) => (Array.isArray(selection)
+    ? selection
+    : selection.type === 'include'
+        ? selection.list
+        : []);
+export const resolveExcludedSkillNames = (selection) => (Array.isArray(selection)
+    ? []
+    : selection.type === 'exclude'
+        ? selection.list
+        : []);
+export const resolveSelectedRuleAssets = async (bundle, patterns) => {
+    const matchedPaths = new Set((await glob(patterns, { cwd: bundle.cwd, absolute: true }))
+        .map(normalizePath));
+    return bundle.rules.filter((asset) => matchedPaths.has(normalizePath(asset.payload.definition.path)));
+};
+export const toDocumentDefinitions = (assets) => assets.map(asset => asset.payload.definition);
+export const toPromptAssetIds = (assets) => (Array.from(new Set(assets.map(asset => asset.id))));

package/dist/packages/workspace-assets/src/helpers.d.ts

@@ -0,0 +1,9 @@
+import type { WorkspaceAsset } from '@vibe-forge/types';
+export declare const resolvePluginIdFromPath: (cwd: string, path: string) => string | undefined;
+export declare const isPluginEnabled: (enabledPlugins: Record<string, boolean>, pluginId?: string) => boolean;
+export declare const mergeRecord: <T>(left?: Record<string, T>, right?: Record<string, T>) => {
+    [x: string]: T;
+};
+export declare const uniqueValues: (values: string[]) => string[];
+export declare const assetOriginPriority: Record<WorkspaceAsset['origin'], number>;
+export declare const toAssetScope: (origin: WorkspaceAsset["origin"]) => WorkspaceAsset["scope"];