@vibe-forge/tsconfigs 0.7.2 → 0.9.0

package/dist/packages/config/src/update.js

@@ -0,0 +1,148 @@
+import { existsSync } from 'node:fs';
+import { mkdir, readFile, writeFile } from 'node:fs/promises';
+import { dirname, extname, resolve } from 'node:path';
+import process from 'node:process';
+import { dump, load } from 'js-yaml';
+import { resetConfigCache } from './load';
+const shouldMaskKey = (key) => /key|token|secret|password/i.test(key);
+const projectConfigPaths = [
+    './.ai.config.json',
+    './infra/.ai.config.json',
+    './.ai.config.yaml',
+    './.ai.config.yml',
+    './infra/.ai.config.yaml',
+    './infra/.ai.config.yml'
+];
+const userConfigPaths = [
+    './.ai.dev.config.json',
+    './infra/.ai.dev.config.json',
+    './.ai.dev.config.yaml',
+    './.ai.dev.config.yml',
+    './infra/.ai.dev.config.yaml',
+    './infra/.ai.dev.config.yml'
+];
+const resolveWritableConfigPath = (workspaceFolder, source) => {
+    const paths = source === 'project' ? projectConfigPaths : userConfigPaths;
+    for (const path of paths) {
+        const resolvedPath = resolve(workspaceFolder, path);
+        if (existsSync(resolvedPath)) {
+            return resolvedPath;
+        }
+    }
+    return resolve(workspaceFolder, paths[0]);
+};
+const parseConfigContent = (format, content) => {
+    if (format === '.yaml' || format === '.yml') {
+        return (load(content) ?? {});
+    }
+    return JSON.parse(content);
+};
+const serializeConfigContent = (format, value) => {
+    if (format === '.yaml' || format === '.yml') {
+        return `${dump(value, { noRefs: true, lineWidth: 120 })}\n`;
+    }
+    return `${JSON.stringify(value, null, 2)}\n`;
+};
+const mergeMaskedValues = (incoming, existing) => {
+    if (Array.isArray(incoming))
+        return incoming;
+    if (incoming != null && typeof incoming === 'object') {
+        const incomingRecord = incoming;
+        const existingRecord = (existing != null && typeof existing === 'object')
+            ? existing
+            : {};
+        return Object.entries(incomingRecord).reduce((acc, [key, val]) => {
+            if (shouldMaskKey(key) && val === '******') {
+                acc[key] = existingRecord[key];
+            }
+            else {
+                acc[key] = mergeMaskedValues(val, existingRecord[key]);
+            }
+            return acc;
+        }, {});
+    }
+    return incoming;
+};
+const updateConfigSection = (config, section, value) => {
+    const nextConfig = { ...config };
+    const sectionValue = (value != null && typeof value === 'object')
+        ? value
+        : {};
+    const updateField = (key, nextValue) => {
+        if (nextValue === undefined) {
+            delete nextConfig[key];
+        }
+        else {
+            nextConfig[key] = nextValue;
+        }
+    };
+    switch (section) {
+        case 'general': {
+            updateField('baseDir', sectionValue.baseDir);
+            updateField('defaultAdapter', sectionValue.defaultAdapter);
+            updateField('defaultModelService', sectionValue.defaultModelService);
+            updateField('defaultModel', sectionValue.defaultModel);
+            updateField('recommendedModels', sectionValue.recommendedModels);
+            updateField('interfaceLanguage', sectionValue.interfaceLanguage);
+            updateField('modelLanguage', sectionValue.modelLanguage);
+            updateField('announcements', sectionValue.announcements);
+            updateField('permissions', mergeMaskedValues(sectionValue.permissions, config.permissions));
+            updateField('env', mergeMaskedValues(sectionValue.env, config.env));
+            updateField('notifications', mergeMaskedValues(sectionValue.notifications, config.notifications));
+            updateField('shortcuts', mergeMaskedValues(sectionValue.shortcuts, config.shortcuts));
+            return nextConfig;
+        }
+        case 'conversation': {
+            updateField('conversation', mergeMaskedValues(sectionValue, config.conversation));
+            return nextConfig;
+        }
+        case 'models': {
+            updateField('models', mergeMaskedValues(sectionValue, config.models));
+            return nextConfig;
+        }
+        case 'modelServices': {
+            updateField('modelServices', mergeMaskedValues(sectionValue, config.modelServices));
+            return nextConfig;
+        }
+        case 'channels': {
+            updateField('channels', mergeMaskedValues(sectionValue, config.channels));
+            return nextConfig;
+        }
+        case 'adapters': {
+            updateField('adapters', mergeMaskedValues(sectionValue, config.adapters));
+            return nextConfig;
+        }
+        case 'plugins': {
+            updateField('plugins', sectionValue.plugins);
+            updateField('enabledPlugins', mergeMaskedValues(sectionValue.enabledPlugins, config.enabledPlugins));
+            updateField('extraKnownMarketplaces', mergeMaskedValues(sectionValue.extraKnownMarketplaces, config.extraKnownMarketplaces));
+            return nextConfig;
+        }
+        case 'mcp': {
+            updateField('mcpServers', mergeMaskedValues(sectionValue.mcpServers, config.mcpServers));
+            updateField('defaultIncludeMcpServers', sectionValue.defaultIncludeMcpServers);
+            updateField('defaultExcludeMcpServers', sectionValue.defaultExcludeMcpServers);
+            updateField('noDefaultVibeForgeMcpServer', sectionValue.noDefaultVibeForgeMcpServer);
+            return nextConfig;
+        }
+        case 'shortcuts': {
+            updateField('shortcuts', mergeMaskedValues(sectionValue, config.shortcuts));
+            return nextConfig;
+        }
+        default:
+            return nextConfig;
+    }
+};
+export const updateConfigFile = async (options) => {
+    const workspaceFolder = options.workspaceFolder ?? process.cwd();
+    const configPath = resolveWritableConfigPath(workspaceFolder, options.source);
+    const format = extname(configPath).toLowerCase();
+    const hasExisting = existsSync(configPath);
+    const existingContent = hasExisting ? await readFile(configPath, 'utf-8') : '';
+    const existingConfig = hasExisting ? parseConfigContent(format, existingContent) : {};
+    const updatedConfig = updateConfigSection(existingConfig, options.section, options.value);
+    await mkdir(dirname(configPath), { recursive: true });
+    await writeFile(configPath, serializeConfigContent(format, updatedConfig), 'utf-8');
+    resetConfigCache();
+    return { configPath, updatedConfig };
+};

package/dist/packages/core/__tests__/cache.spec.d.ts

@@ -0,0 +1 @@
+import '../../adapters/codex/src/adapter-config.js';

package/dist/packages/core/__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 '#~/utils/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/core/__tests__/config-load.spec.d.ts

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

package/dist/packages/core/__tests__/config-load.spec.js

@@ -0,0 +1,41 @@
+import { mkdtemp, rm, writeFile } from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import process from 'node:process';
+import { describe, expect, it } from 'vitest';
+import { loadConfig, resetConfigCache } from '#~/config/load.js';
+const DISABLE_DEV_CONFIG_ENV = '__VF_PROJECT_AI_DISABLE_DEV_CONFIG__';
+describe('loadConfig', () => {
+    it('can skip workspace dev config via env override', async () => {
+        const tempDir = await mkdtemp(path.join(os.tmpdir(), 'vf-config-load-'));
+        const previousCwd = process.cwd();
+        const previousDisableDevConfig = process.env[DISABLE_DEV_CONFIG_ENV];
+        try {
+            await writeFile(path.join(tempDir, '.ai.config.json'), JSON.stringify({
+                defaultModel: 'project-model'
+            }));
+            await writeFile(path.join(tempDir, '.ai.dev.config.json'), JSON.stringify({
+                defaultModel: 'dev-model'
+            }));
+            process.chdir(tempDir);
+            process.env[DISABLE_DEV_CONFIG_ENV] = '1';
+            resetConfigCache();
+            const [projectConfig, userConfig] = await loadConfig({
+                jsonVariables: {}
+            });
+            expect(projectConfig?.defaultModel).toBe('project-model');
+            expect(userConfig).toBeUndefined();
+        }
+        finally {
+            process.chdir(previousCwd);
+            if (previousDisableDevConfig == null) {
+                delete process.env[DISABLE_DEV_CONFIG_ENV];
+            }
+            else {
+                process.env[DISABLE_DEV_CONFIG_ENV] = previousDisableDevConfig;
+            }
+            resetConfigCache();
+            await rm(tempDir, { force: true, recursive: true });
+        }
+    });
+});

package/dist/packages/core/__tests__/create-logger.spec.d.ts

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

package/dist/packages/core/__tests__/create-logger.spec.js

@@ -0,0 +1,98 @@
+import { mkdir, mkdtemp, readFile, readdir, rm, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { afterEach, describe, expect, it, vi } from 'vitest';
+import { createLogger } from '#~/utils/create-logger.js';
+async function listFiles(dir) {
+    const entries = await readdir(dir, { withFileTypes: true });
+    const files = await Promise.all(entries.map(async (entry) => {
+        const entryPath = join(dir, entry.name);
+        if (entry.isDirectory()) {
+            return listFiles(entryPath);
+        }
+        return [entryPath];
+    }));
+    return files.flat();
+}
+describe('createLogger', () => {
+    const tempDirs = [];
+    afterEach(async () => {
+        vi.useRealTimers();
+        await Promise.all(tempDirs.splice(0).map(dir => rm(dir, { recursive: true, force: true })));
+    });
+    it('creates a canonical session log file under the task log directory', async () => {
+        const cwd = await mkdtemp(join(tmpdir(), 'vf-create-logger-'));
+        tempDirs.push(cwd);
+        const logger = createLogger(cwd, 'task-1', 'session-1');
+        logger.info('hello');
+        await new Promise((resolve) => {
+            logger.stream.end(() => resolve());
+        });
+        const files = await listFiles(join(cwd, '.ai/logs/task-1'));
+        expect(files).toEqual([join(cwd, '.ai/logs/task-1/session-1.log.md')]);
+        expect(await readFile(files[0], 'utf8')).toContain('hello');
+    });
+    it('uses info as the default level', async () => {
+        const cwd = await mkdtemp(join(tmpdir(), 'vf-create-logger-'));
+        tempDirs.push(cwd);
+        const logger = createLogger(cwd, 'task-1', 'session-1');
+        logger.debug('Claude Code CLI stdout:', { line: 'hidden by default' });
+        logger.info('hello');
+        await new Promise((resolve) => {
+            logger.stream.end(() => resolve());
+        });
+        const canonicalPath = join(cwd, '.ai/logs/task-1/session-1.log.md');
+        const content = await readFile(canonicalPath, 'utf8');
+        expect(content).toContain('__I__ hello');
+        expect(content).not.toContain('Claude Code CLI stdout:');
+        expect(content).not.toContain('__D__');
+    });
+    it('keeps writing resumed logs into the canonical session file even if legacy dated logs exist', async () => {
+        const cwd = await mkdtemp(join(tmpdir(), 'vf-create-logger-'));
+        tempDirs.push(cwd);
+        const legacyDir = join(cwd, '.ai/logs/task-1/2026-3-19-22');
+        const legacyPath = join(legacyDir, 'session-1.log.md');
+        const canonicalPath = join(cwd, '.ai/logs/task-1/session-1.log.md');
+        await mkdir(legacyDir, { recursive: true });
+        await writeFile(legacyPath, '# legacy log\n');
+        const logger = createLogger(cwd, 'task-1', 'session-1');
+        logger.info('follow up');
+        await new Promise((resolve) => {
+            logger.stream.end(() => resolve());
+        });
+        const files = await listFiles(join(cwd, '.ai/logs/task-1'));
+        expect(files.sort()).toEqual([canonicalPath, legacyPath].sort());
+        expect(await readFile(canonicalPath, 'utf8')).toContain('follow up');
+        expect(await readFile(legacyPath, 'utf8')).toBe('# legacy log\n');
+    });
+    it('skips debug entries when log level is info', async () => {
+        const cwd = await mkdtemp(join(tmpdir(), 'vf-create-logger-'));
+        tempDirs.push(cwd);
+        vi.useFakeTimers();
+        vi.setSystemTime(new Date('2026-03-20T10:00:00.000Z'));
+        const logger = createLogger(cwd, 'task-1', 'session-1', '', 'info');
+        logger.debug('Claude Code CLI stdout:', { line: 'debug only' });
+        logger.info('session started');
+        await new Promise((resolve) => {
+            logger.stream.end(() => resolve());
+        });
+        const canonicalPath = join(cwd, '.ai/logs/task-1/session-1.log.md');
+        const content = await readFile(canonicalPath, 'utf8');
+        expect(content).toContain('__I__ session started');
+        expect(content).not.toContain('Claude Code CLI stdout:');
+        expect(content).not.toContain('__D__');
+    });
+    it('keeps debug entries when log level is debug', async () => {
+        const cwd = await mkdtemp(join(tmpdir(), 'vf-create-logger-'));
+        tempDirs.push(cwd);
+        const logger = createLogger(cwd, 'task-1', 'session-1', '', 'debug');
+        logger.debug('Claude Code CLI stdout:', { line: 'debug enabled' });
+        await new Promise((resolve) => {
+            logger.stream.end(() => resolve());
+        });
+        const canonicalPath = join(cwd, '.ai/logs/task-1/session-1.log.md');
+        const content = await readFile(canonicalPath, 'utf8');
+        expect(content).toContain('__D__ Claude Code CLI stdout:');
+        expect(content).toContain('"line": "debug enabled"');
+    });
+});

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

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

package/dist/packages/core/__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 '#~/utils/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/core/__tests__/env.spec.d.ts

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

package/dist/packages/core/__tests__/env.spec.js

@@ -0,0 +1,27 @@
+import { afterEach, describe, expect, it, vi } from 'vitest';
+describe('env helpers', () => {
+    afterEach(() => {
+        vi.unstubAllEnvs();
+        vi.resetModules();
+    });
+    it('forces debug level when __VF_PROJECT_AI_SERVER_DEBUG__ is enabled', async () => {
+        const { resolveServerLogLevel } = await import('../src/env');
+        expect(resolveServerLogLevel({
+            __VF_PROJECT_AI_SERVER_LOG_LEVEL__: 'error',
+            __VF_PROJECT_AI_SERVER_DEBUG__: 'true'
+        })).toBe('debug');
+    });
+    it('defaults to info when no debug config is provided', async () => {
+        const { resolveServerLogLevel } = await import('../src/env');
+        expect(resolveServerLogLevel({})).toBe('info');
+    });
+    it('parses __VF_PROJECT_AI_SERVER_DEBUG__ from process env', async () => {
+        vi.stubEnv('__VF_PROJECT_AI_SERVER_DEBUG__', 'true');
+        vi.stubEnv('__VF_PROJECT_AI_SERVER_LOG_LEVEL__', 'warn');
+        const { loadEnv } = await import('../src/env');
+        expect(loadEnv()).toEqual(expect.objectContaining({
+            __VF_PROJECT_AI_SERVER_DEBUG__: true,
+            __VF_PROJECT_AI_SERVER_LOG_LEVEL__: 'warn'
+        }));
+    });
+});

package/dist/packages/core/__tests__/generate-adapter-query-options.spec.d.ts

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

package/dist/packages/core/__tests__/generate-adapter-query-options.spec.js

@@ -0,0 +1,103 @@
+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 { generateAdapterQueryOptions } from '#~/controllers/task/generate-adapter-query-options.js';
+const tempDirs = [];
+const createWorkspace = async () => {
+    const dir = await mkdtemp(join(tmpdir(), 'generate-adapter-query-options-'));
+    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('generateAdapterQueryOptions', () => {
+    it('loads local and remote entity rule references without crashing', async () => {
+        const workspace = await createWorkspace();
+        await writeDocument(join(workspace, '.ai/entities/api-developer/rules/migrate.md'), '---\ndescription: 文件内描述\n---\n遵循新的 API 迁移流程');
+        await writeDocument(join(workspace, '.ai/entities/api-developer/index.json'), JSON.stringify({
+            prompt: '你是 API 开发实体',
+            rules: [
+                {
+                    path: './rules/migrate.md',
+                    desc: '迁移老范式的 API 代码到新范式'
+                },
+                {
+                    type: 'remote',
+                    tags: ['business', 'api-develop'],
+                    desc: '遇到未说明的方法时，可查询远程知识库'
+                }
+            ]
+        }, null, 2));
+        const [{ rules }, resolvedConfig] = await generateAdapterQueryOptions('entity', 'api-developer', workspace);
+        expect(rules).toHaveLength(2);
+        expect(resolvedConfig.systemPrompt).toContain('迁移老范式的 API 代码到新范式');
+        expect(resolvedConfig.systemPrompt).toContain('遵循新的 API 迁移流程');
+        expect(resolvedConfig.systemPrompt).toContain('遇到未说明的方法时，可查询远程知识库');
+        expect(resolvedConfig.systemPrompt).toContain('知识库标签：business, api-develop');
+    });
+    it('loads explicitly included skills into the generated system prompt', async () => {
+        const workspace = await createWorkspace();
+        await writeDocument(join(workspace, '.ai/skills/research/SKILL.md'), '---\ndescription: 检索资料\n---\n阅读 README.md');
+        await writeDocument(join(workspace, '.ai/skills/review/SKILL.md'), '---\ndescription: 代码评审\n---\n检查风险');
+        const [, resolvedConfig] = await generateAdapterQueryOptions(undefined, undefined, workspace, {
+            skills: {
+                include: ['research']
+            }
+        });
+        expect(resolvedConfig.systemPrompt).toContain('技能名称：research');
+        expect(resolvedConfig.systemPrompt).toContain('技能介绍：检索资料');
+        expect(resolvedConfig.systemPrompt).toContain('research：检索资料');
+        expect(resolvedConfig.systemPrompt).not.toContain('review：代码评审');
+    });
+    it('removes excluded skills from the generated skill routes', async () => {
+        const workspace = await createWorkspace();
+        await writeDocument(join(workspace, '.ai/skills/research/SKILL.md'), '---\ndescription: 检索资料\n---\n阅读 README.md');
+        await writeDocument(join(workspace, '.ai/skills/review/SKILL.md'), '---\ndescription: 代码评审\n---\n检查风险');
+        const [, resolvedConfig] = await generateAdapterQueryOptions(undefined, undefined, workspace, {
+            skills: {
+                exclude: ['review']
+            }
+        });
+        expect(resolvedConfig.systemPrompt).toContain('research：检索资料');
+        expect(resolvedConfig.systemPrompt).not.toContain('review：代码评审');
+        expect(resolvedConfig.systemPrompt).not.toContain('技能名称：review');
+    });
+    it('supports entity skill include selectors', async () => {
+        const workspace = await createWorkspace();
+        await writeDocument(join(workspace, '.ai/skills/research/SKILL.md'), '---\ndescription: 检索资料\n---\n阅读 README.md');
+        await writeDocument(join(workspace, '.ai/skills/review/SKILL.md'), '---\ndescription: 代码评审\n---\n检查风险');
+        await writeDocument(join(workspace, '.ai/entities/api-developer/index.json'), JSON.stringify({
+            prompt: '你是 API 开发实体',
+            skills: {
+                type: 'include',
+                list: ['review']
+            }
+        }, null, 2));
+        const [, resolvedConfig] = await generateAdapterQueryOptions('entity', 'api-developer', workspace);
+        expect(resolvedConfig.systemPrompt).toContain('技能名称：review');
+        expect(resolvedConfig.systemPrompt).toContain('review：代码评审');
+        expect(resolvedConfig.systemPrompt).not.toContain('research：检索资料');
+    });
+    it('supports entity skill exclude selectors', async () => {
+        const workspace = await createWorkspace();
+        await writeDocument(join(workspace, '.ai/skills/research/SKILL.md'), '---\ndescription: 检索资料\n---\n阅读 README.md');
+        await writeDocument(join(workspace, '.ai/skills/review/SKILL.md'), '---\ndescription: 代码评审\n---\n检查风险');
+        await writeDocument(join(workspace, '.ai/entities/api-developer/index.json'), JSON.stringify({
+            prompt: '你是 API 开发实体',
+            skills: {
+                type: 'exclude',
+                list: ['review']
+            }
+        }, null, 2));
+        const [, resolvedConfig] = await generateAdapterQueryOptions('entity', 'api-developer', workspace);
+        expect(resolvedConfig.systemPrompt).toContain('research：检索资料');
+        expect(resolvedConfig.systemPrompt).not.toContain('review：代码评审');
+        expect(resolvedConfig.systemPrompt).not.toContain('技能名称：review');
+    });
+});

package/dist/packages/core/__tests__/hook-bridge.spec.d.ts

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