@vibe-forge/tsconfigs 0.7.2 → 0.8.0

package/dist/packages/task-support/__tests__/cache.spec.js

@@ -0,0 +1,27 @@
+import { mkdtemp, rm } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { afterEach, describe, expect, it } from 'vitest';
+import '../../adapters/codex/src/adapter-config.js';
+import { getCache, getCachePath, setCache } from '#~/cache.js';
+describe('cache utils', () => {
+    const tempDirs = [];
+    afterEach(async () => {
+        await Promise.all(tempDirs.splice(0).map(dir => rm(dir, { recursive: true, force: true })));
+    });
+    it('returns undefined when the cache file does not exist', async () => {
+        const cwd = await mkdtemp(join(tmpdir(), 'vf-cache-'));
+        tempDirs.push(cwd);
+        const result = await getCache(cwd, 'task-1', 'session-1', 'adapter.codex.threads');
+        expect(result).toBeUndefined();
+    });
+    it('writes and reads cache values for a session-scoped key', async () => {
+        const cwd = await mkdtemp(join(tmpdir(), 'vf-cache-'));
+        tempDirs.push(cwd);
+        const expectedValue = { sessionA: 'thr_123' };
+        const writeResult = await setCache(cwd, 'task-1', 'session-1', 'adapter.codex.threads', expectedValue);
+        const readResult = await getCache(cwd, 'task-1', 'session-1', 'adapter.codex.threads');
+        expect(writeResult.cachePath).toBe(getCachePath(cwd, 'task-1', 'session-1', 'adapter.codex.threads'));
+        expect(readResult).toEqual(expectedValue);
+    });
+});

package/dist/packages/task-support/__tests__/default-vibe-forge-mcp.spec.d.ts

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

package/dist/packages/task-support/__tests__/default-vibe-forge-mcp.spec.js

@@ -0,0 +1,28 @@
+import process from 'node:process';
+import { describe, expect, it } from 'vitest';
+import { DEFAULT_VIBE_FORGE_MCP_SERVER_NAME, resolveDefaultVibeForgeMcpServerConfig, resolveUseDefaultVibeForgeMcpServer } from '#~/default-vibe-forge-mcp.js';
+describe('default Vibe Forge MCP', () => {
+    it('enables the built-in MCP server by default', () => {
+        expect(resolveUseDefaultVibeForgeMcpServer({})).toBe(true);
+    });
+    it('lets config disable the built-in MCP server unless runtime overrides it', () => {
+        expect(resolveUseDefaultVibeForgeMcpServer({
+            projectConfig: {
+                noDefaultVibeForgeMcpServer: true
+            }
+        })).toBe(false);
+        expect(resolveUseDefaultVibeForgeMcpServer({
+            projectConfig: {
+                noDefaultVibeForgeMcpServer: true
+            },
+            runtimeValue: true
+        })).toBe(true);
+    });
+    it('resolves the managed MCP CLI wrapper as a stdio server command', () => {
+        expect(DEFAULT_VIBE_FORGE_MCP_SERVER_NAME).toBe('vibe-forge');
+        expect(resolveDefaultVibeForgeMcpServerConfig()).toEqual({
+            command: process.execPath,
+            args: [expect.stringMatching(/packages\/mcp\/cli\.js$/)]
+        });
+    });
+});

package/dist/packages/task-support/__tests__/definition-loader.spec.d.ts

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

package/dist/packages/task-support/__tests__/definition-loader.spec.js

@@ -0,0 +1,108 @@
+import { mkdir, mkdtemp, rm, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { dirname, join } from 'node:path';
+import { afterEach, describe, expect, it } from 'vitest';
+import { DefinitionLoader } from '#~/definition-loader.js';
+const tempDirs = [];
+const createWorkspace = async () => {
+    const dir = await mkdtemp(join(tmpdir(), 'definition-loader-'));
+    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('definitionLoader', () => {
+    it('generates skill prompts with stable names, descriptions and relative paths', () => {
+        const cwd = '/workspace/project';
+        const loader = new DefinitionLoader(cwd);
+        const prompt = loader.generateSkillsPrompt([
+            {
+                path: join(cwd, '.ai/skills/research/SKILL.md'),
+                body: '阅读 README.md\n',
+                attributes: {
+                    description: '检索项目信息'
+                }
+            }
+        ]);
+        expect(prompt).toContain('技能名称：research');
+        expect(prompt).toContain('技能介绍：检索项目信息');
+        expect(prompt).toContain('技能文件资源路径：.ai/skills/research');
+        expect(prompt).not.toContain('/workspace/project/.ai/skills/research');
+    });
+    it('generates spec routes with logical identifiers instead of file paths', () => {
+        const cwd = '/workspace/project';
+        const loader = new DefinitionLoader(cwd);
+        const prompt = loader.generateSpecRoutePrompt([
+            {
+                path: join(cwd, '.ai/specs/release/index.md'),
+                body: '发布流程\n执行发布任务',
+                attributes: {
+                    params: [
+                        {
+                            name: 'version',
+                            description: '版本号'
+                        }
+                    ]
+                }
+            },
+            {
+                path: join(cwd, '.ai/specs/internal.md'),
+                body: '内部流程',
+                attributes: {
+                    always: false
+                }
+            }
+        ]);
+        expect(prompt).toContain('流程名称：release');
+        expect(prompt).toContain('介绍：发布流程');
+        expect(prompt).toContain('标识：release');
+        expect(prompt).toContain('    - version：版本号');
+        expect(prompt).not.toContain('.ai/specs/release/index.md');
+        expect(prompt).not.toContain('internal');
+    });
+    it('generates entity routes from summaries instead of full bodies', () => {
+        const cwd = '/workspace/project';
+        const loader = new DefinitionLoader(cwd);
+        const prompt = loader.generateEntitiesRoutePrompt([
+            {
+                path: join(cwd, '.ai/entities/reviewer/README.md'),
+                body: '负责代码审查\n需要关注变更风险',
+                attributes: {}
+            },
+            {
+                path: join(cwd, '.ai/entities/hidden.md'),
+                body: '不应暴露',
+                attributes: {
+                    name: 'hidden',
+                    always: false
+                }
+            }
+        ]);
+        expect(prompt).toContain('reviewer：负责代码审查');
+        expect(prompt).not.toContain('需要关注变更风险');
+        expect(prompt).not.toContain('hidden');
+    });
+    it('loads plugin directory specs and README based entities consistently', async () => {
+        const workspace = await createWorkspace();
+        const loader = new DefinitionLoader(workspace);
+        await writeDocument(join(workspace, '.ai/plugins/demo/specs/ship/index.md'), '---\ndescription: 插件发布流程\n---\n执行插件发布');
+        await writeDocument(join(workspace, '.ai/entities/reviewer/README.md'), '---\ndescription: 代码审查实体\n---\n负责代码审查');
+        await writeDocument(join(workspace, '.ai/entities/planner.md'), '---\ndescription: 任务规划实体\n---\n负责拆解任务');
+        const pluginSpec = await loader.loadSpec('ship');
+        const reviewer = await loader.loadEntity('reviewer');
+        const planner = await loader.loadEntity('planner');
+        const entities = await loader.loadDefaultEntities();
+        expect(pluginSpec?.path).toContain('/.ai/plugins/demo/specs/ship/index.md');
+        expect(reviewer?.path).toContain('/.ai/entities/reviewer/README.md');
+        expect(planner?.path).toContain('/.ai/entities/planner.md');
+        expect(entities.map((entity) => entity.path)).toEqual([
+            join(workspace, '.ai/entities/planner.md'),
+            join(workspace, '.ai/entities/reviewer/README.md')
+        ]);
+    });
+});

package/dist/packages/task-support/__tests__/model-selection.spec.d.ts

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

package/dist/packages/task-support/__tests__/model-selection.spec.js

@@ -0,0 +1,153 @@
+import { describe, expect, it } from 'vitest';
+import { doesModelMatchSelector, evaluateAdapterModelRules, listServiceModels, resolveAdapterConfiguredDefaultModel, resolveAdapterModelCompatibility, resolveDefaultModelSelection, resolveModelDefaultAdapter, resolveModelMetadata, resolveModelSelection } from '#~/model-selection.js';
+const modelServices = {
+    serviceA: {
+        apiBaseUrl: 'https://service-a.example.com',
+        apiKey: 'token-a',
+        models: ['modelX', 'modelAOnly']
+    },
+    serviceB: {
+        apiBaseUrl: 'https://service-b.example.com',
+        apiKey: 'token-b',
+        models: ['modelX', 'modelBOnly']
+    }
+};
+describe('model selection utilities', () => {
+    it('resolves exact selector metadata before service-level metadata', () => {
+        const models = {
+            serviceA: { defaultAdapter: 'claude-code' },
+            'serviceA,modelX': { defaultAdapter: 'codex' }
+        };
+        expect(resolveModelDefaultAdapter({
+            model: 'serviceA,modelX',
+            models
+        })).toBe('codex');
+        expect(resolveModelMetadata({
+            model: 'serviceA,modelAOnly',
+            models
+        })).toEqual({ defaultAdapter: 'claude-code' });
+    });
+    it('ignores invalid selector keys and falls back to service entries', () => {
+        const models = {
+            modelX: { defaultAdapter: 'codex' },
+            serviceB: { defaultAdapter: 'claude-code' }
+        };
+        expect(resolveModelDefaultAdapter({
+            model: 'serviceB,modelX',
+            models
+        })).toBe('claude-code');
+    });
+    it('resolves raw models through the preferred default service', () => {
+        const serviceModels = listServiceModels(modelServices);
+        expect(resolveModelSelection({
+            value: 'modelX',
+            serviceModels,
+            preferredServiceKey: 'serviceB',
+            preserveUnknown: false
+        })).toBe('serviceB,modelX');
+    });
+    it('falls back to default service first model when no explicit model is configured', () => {
+        const serviceModels = listServiceModels(modelServices);
+        expect(resolveDefaultModelSelection({
+            defaultModelService: 'serviceB',
+            serviceModels,
+            preserveUnknownDefaultModel: false
+        })).toBe('serviceB,modelX');
+    });
+    it('matches service selectors and exact selectors for routed models', () => {
+        expect(doesModelMatchSelector({
+            model: 'serviceA,modelX',
+            selector: 'serviceA'
+        })).toBe(true);
+        expect(doesModelMatchSelector({
+            model: 'serviceA,modelX',
+            selector: 'serviceA,modelX'
+        })).toBe(true);
+        expect(doesModelMatchSelector({
+            model: 'serviceA,modelX',
+            selector: 'serviceB'
+        })).toBe(false);
+    });
+    it('prefers adapter defaultModel before global defaults', () => {
+        const serviceModels = listServiceModels(modelServices);
+        expect(resolveAdapterConfiguredDefaultModel({
+            adapterConfig: {
+                defaultModel: 'serviceB,modelBOnly'
+            },
+            serviceModels,
+            preferredServiceKey: 'serviceA',
+            preserveUnknown: false
+        })).toBe('serviceB,modelBOnly');
+    });
+    it('treats service selectors as valid includeModels rules', () => {
+        expect(evaluateAdapterModelRules({
+            model: 'serviceA,modelX',
+            adapterConfig: {
+                includeModels: ['serviceA']
+            }
+        })).toMatchObject({
+            allowed: true
+        });
+        expect(evaluateAdapterModelRules({
+            model: 'serviceB,modelX',
+            adapterConfig: {
+                includeModels: ['serviceA']
+            }
+        })).toMatchObject({
+            allowed: false,
+            reason: 'not_included'
+        });
+    });
+    it('does not let includeModels reject the literal default model', () => {
+        expect(evaluateAdapterModelRules({
+            model: 'default',
+            adapterConfig: {
+                includeModels: ['serviceA']
+            }
+        })).toMatchObject({
+            allowed: true
+        });
+    });
+    it('falls back to adapter defaultModel when the selected model is excluded', () => {
+        const serviceModels = listServiceModels(modelServices);
+        expect(resolveAdapterModelCompatibility({
+            adapter: 'codex',
+            model: 'serviceA,modelX',
+            adapterConfig: {
+                defaultModel: 'serviceB,modelBOnly',
+                excludeModels: ['serviceA,modelX']
+            },
+            serviceModels,
+            preferredServiceKey: 'serviceA',
+            preserveUnknownDefaultModel: false
+        })).toMatchObject({
+            model: 'serviceB,modelBOnly',
+            warning: {
+                adapter: 'codex',
+                requestedModel: 'serviceA,modelX',
+                resolvedModel: 'serviceB,modelBOnly',
+                reason: 'excluded'
+            }
+        });
+    });
+    it('returns an error when adapter rules reject the model and no defaultModel exists', () => {
+        const serviceModels = listServiceModels(modelServices);
+        expect(resolveAdapterModelCompatibility({
+            adapter: 'codex',
+            model: 'serviceB,modelX',
+            adapterConfig: {
+                includeModels: ['serviceA']
+            },
+            serviceModels,
+            preferredServiceKey: 'serviceA',
+            preserveUnknownDefaultModel: false
+        })).toMatchObject({
+            error: {
+                type: 'missing_default_model',
+                adapter: 'codex',
+                requestedModel: 'serviceB,modelX',
+                reason: 'not_included'
+            }
+        });
+    });
+});

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

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

package/dist/packages/task-support/__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 '#~/workspace-assets.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/task-support/src/cache.d.ts

@@ -0,0 +1,6 @@
+import type { Cache } from '@vibe-forge/types';
+export declare const getCachePath: (cwd: string, taskId: string, sessionId: string | undefined, key: keyof Cache) => string;
+export declare const setCache: <K extends keyof Cache>(cwd: string, taskId: string, sessionId: string | undefined, key: K, value: Cache[K]) => Promise<{
+    cachePath: string;
+}>;
+export declare const getCache: <K extends keyof Cache>(cwd: string, taskId: string, sessionId: string | undefined, key: K) => Promise<Cache[K] | undefined>;

package/dist/packages/task-support/src/cache.js

@@ -0,0 +1,34 @@
+import * as fs from 'node:fs/promises';
+import { dirname, resolve } from 'node:path';
+export const getCachePath = (cwd, taskId, sessionId, key) => {
+    const taskDir = resolve(cwd, '.ai/caches', taskId);
+    const cacheDir = sessionId ? resolve(taskDir, sessionId) : taskDir;
+    return resolve(cacheDir, `${key}.json`);
+};
+export const setCache = async (cwd, taskId, sessionId, key, value) => {
+    const cachePath = getCachePath(cwd, taskId, sessionId, key);
+    const cacheDir = dirname(cachePath);
+    try {
+        await fs.access(cacheDir);
+    }
+    catch {
+        await fs.mkdir(cacheDir, { recursive: true });
+    }
+    await fs.writeFile(cachePath, JSON.stringify(value, null, 2), {
+        flag: 'w'
+    });
+    return { cachePath };
+};
+export const getCache = async (cwd, taskId, sessionId, key) => {
+    const cachePath = getCachePath(cwd, taskId, sessionId, key);
+    try {
+        await fs.access(cachePath);
+    }
+    catch (error) {
+        if (error.code === 'ENOENT') {
+            return undefined;
+        }
+        throw error;
+    }
+    return JSON.parse(await fs.readFile(cachePath, 'utf-8'));
+};

package/dist/packages/task-support/src/default-vibe-forge-mcp.d.ts

@@ -0,0 +1,11 @@
+import type { Config } from '@vibe-forge/types';
+export declare const DEFAULT_VIBE_FORGE_MCP_SERVER_NAME = "vibe-forge";
+export declare const resolveUseDefaultVibeForgeMcpServer: (options: {
+    runtimeValue?: boolean;
+    projectConfig?: Config;
+    userConfig?: Config;
+}) => boolean;
+export declare const resolveDefaultVibeForgeMcpServerConfig: () => {
+    command: string;
+    args: string[];
+} | undefined;

package/dist/packages/task-support/src/default-vibe-forge-mcp.js

@@ -0,0 +1,41 @@
+import { existsSync } from 'node:fs';
+import { dirname, resolve } from 'node:path';
+import process from 'node:process';
+import { createRequire } from 'node:module';
+export const DEFAULT_VIBE_FORGE_MCP_SERVER_NAME = 'vibe-forge';
+export const resolveUseDefaultVibeForgeMcpServer = (options) => (options.runtimeValue ??
+    (options.userConfig?.noDefaultVibeForgeMcpServer != null
+        ? !options.userConfig.noDefaultVibeForgeMcpServer
+        : undefined) ??
+    (options.projectConfig?.noDefaultVibeForgeMcpServer != null
+        ? !options.projectConfig.noDefaultVibeForgeMcpServer
+        : undefined) ??
+    true);
+export const resolveDefaultVibeForgeMcpServerConfig = () => {
+    try {
+        const packageResolver = typeof require === 'function'
+            ? require
+            : createRequire(resolve(process.cwd(), '__vf_task_support_mcp_resolver__.js'));
+        const workspacePackageJsonPath = resolve(process.cwd(), 'packages/mcp/package.json');
+        const packageJsonPath = existsSync(workspacePackageJsonPath)
+            ? workspacePackageJsonPath
+            : resolvePublishedMcpPackageJsonPath(packageResolver);
+        const packageDir = dirname(packageJsonPath);
+        return {
+            command: process.execPath,
+            args: [resolve(packageDir, 'cli.js')]
+        };
+    }
+    catch {
+        return undefined;
+    }
+};
+const resolvePublishedMcpPackageJsonPath = (packageResolver) => {
+    try {
+        const appRuntimePackageJsonPath = packageResolver.resolve('@vibe-forge/app-runtime/package.json');
+        return createRequire(appRuntimePackageJsonPath).resolve('@vibe-forge/mcp/package.json');
+    }
+    catch {
+        return packageResolver.resolve('@vibe-forge/mcp/package.json');
+    }
+};

package/dist/packages/task-support/src/definition-loader.d.ts

@@ -0,0 +1,26 @@
+import type { Definition, Entity, Rule, RuleReference, Skill, Spec } from '@vibe-forge/types';
+/**
+ * 以结构化的方式加载本地文档数据
+ */
+export declare const loadLocalDocuments: <Attrs extends object>(paths: string[]) => Promise<Definition<Attrs>[]>;
+export declare class DefinitionLoader {
+    private readonly cwd;
+    constructor(cwd?: string);
+    private scan;
+    loadRules(rules: RuleReference[], options?: {
+        baseDir?: string;
+    }): Promise<Definition<Rule>[]>;
+    loadDefaultRules(): Promise<Definition<Rule>[]>;
+    generateRulesPrompt(rules: Definition<Rule>[]): string;
+    loadSkills(skills?: string[]): Promise<Definition<Skill>[]>;
+    loadDefaultSkills(): Promise<Definition<Skill>[]>;
+    generateSkillsPrompt(skills: Definition<Skill>[]): string;
+    generateSkillsRoutePrompt(skills: Definition<Skill>[]): string;
+    loadSpec(name: string): Promise<Definition<Spec> | undefined>;
+    loadDefaultSpecs(): Promise<Definition<Spec>[]>;
+    generateSpecRoutePrompt(specsDocuments: Definition<Spec>[]): string;
+    loadEntity(name: string): Promise<Definition<Entity> | undefined>;
+    private loadEntityFromJson;
+    loadDefaultEntities(): Promise<Definition<Entity>[]>;
+    generateEntitiesRoutePrompt(entities: Definition<Entity>[]): string;
+}