@vibe-forge/tsconfigs 0.7.2 → 0.8.0

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

@@ -0,0 +1,471 @@
+import { PassThrough } from 'node:stream';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { run } from '#~/controllers/task/run.js';
+const { prepareMock, loadAdapterMock, callHookMock, createAdapterHookBridgeMock, initMock, queryMock } = vi.hoisted(() => ({
+    prepareMock: vi.fn(),
+    loadAdapterMock: vi.fn(),
+    callHookMock: vi.fn(),
+    createAdapterHookBridgeMock: vi.fn(),
+    initMock: vi.fn(),
+    queryMock: vi.fn()
+}));
+vi.mock('#~/controllers/task/prepare.js', () => ({
+    prepare: prepareMock
+}));
+vi.mock('#~/adapter/index.js', () => ({
+    loadAdapter: loadAdapterMock
+}));
+vi.mock('#~/hooks/call.js', () => ({
+    callHook: callHookMock
+}));
+vi.mock('#~/hooks/bridge.js', () => ({
+    createAdapterHookBridge: createAdapterHookBridgeMock
+}));
+const createLogger = () => ({
+    stream: new PassThrough(),
+    info: vi.fn(),
+    warn: vi.fn(),
+    error: vi.fn(),
+    debug: vi.fn()
+});
+const createAssets = () => ({
+    cwd: '/tmp/project',
+    assets: [],
+    rules: [],
+    specs: [],
+    entities: [],
+    skills: [],
+    mcpServers: {},
+    hookPlugins: [],
+    enabledPlugins: {},
+    extraKnownMarketplaces: {},
+    defaultIncludeMcpServers: [],
+    defaultExcludeMcpServers: []
+});
+const createAdapters = (adapters) => adapters;
+const createCtx = () => ({
+    ctxId: 'ctx-1',
+    cwd: '/tmp/project',
+    env: {},
+    cache: {
+        set: vi.fn().mockResolvedValue({ cachePath: '/tmp/project/.ai/cache/base.json' }),
+        get: vi.fn()
+    },
+    logger: createLogger(),
+    configs: [
+        {
+            adapters: createAdapters({
+                codex: {}
+            })
+        },
+        undefined
+    ],
+    assets: createAssets()
+});
+describe('task run adapter init', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+        initMock.mockResolvedValue(undefined);
+        queryMock.mockResolvedValue({
+            kill: vi.fn(),
+            emit: vi.fn()
+        });
+        loadAdapterMock.mockResolvedValue({
+            init: initMock,
+            query: queryMock
+        });
+        createAdapterHookBridgeMock.mockReturnValue({
+            start: vi.fn().mockResolvedValue(undefined),
+            prepareInitialPrompt: vi.fn(async (prompt) => prompt),
+            wrapSession: vi.fn((session) => session),
+            handleOutput: vi.fn()
+        });
+        callHookMock.mockResolvedValue({ continue: true });
+    });
+    it('runs adapter init before query', async () => {
+        const ctx = createCtx();
+        prepareMock.mockResolvedValue([ctx]);
+        await run({
+            adapter: 'codex',
+            cwd: ctx.cwd,
+            env: {}
+        }, {
+            type: 'create',
+            runtime: 'cli',
+            sessionId: 'session-cli',
+            description: 'hello',
+            onEvent: vi.fn()
+        });
+        expect(loadAdapterMock).toHaveBeenCalledWith('codex');
+        expect(initMock).toHaveBeenCalledTimes(1);
+        expect(initMock).toHaveBeenCalledWith(ctx);
+        expect(queryMock).toHaveBeenCalledTimes(1);
+        const initCallOrder = initMock.mock.invocationCallOrder[0];
+        const queryCallOrder = queryMock.mock.invocationCallOrder[0];
+        expect(initCallOrder).toBeDefined();
+        expect(queryCallOrder).toBeDefined();
+        if (initCallOrder == null || queryCallOrder == null) {
+            throw new Error('expected init and query to be invoked');
+        }
+        expect(initCallOrder).toBeLessThan(queryCallOrder);
+    });
+    it('also runs adapter init for non-CLI runtimes', async () => {
+        const ctx = createCtx();
+        prepareMock.mockResolvedValue([ctx]);
+        await run({
+            adapter: 'codex',
+            cwd: ctx.cwd,
+            env: {}
+        }, {
+            type: 'create',
+            runtime: 'server',
+            sessionId: 'session-server',
+            description: 'hello',
+            onEvent: vi.fn()
+        });
+        expect(initMock).toHaveBeenCalledTimes(1);
+        expect(initMock).toHaveBeenCalledWith(ctx);
+        expect(queryMock).toHaveBeenCalledTimes(1);
+    });
+    it('attaches the adapter asset plan to query options', async () => {
+        const ctx = createCtx();
+        ctx.assets.assets = [
+            {
+                id: 'nativePlugin:claude-code:logger',
+                kind: 'nativePlugin',
+                pluginId: 'logger',
+                origin: 'config',
+                scope: 'project',
+                enabled: true,
+                targets: ['claude-code'],
+                payload: {
+                    name: 'logger',
+                    enabled: true
+                }
+            }
+        ];
+        ctx.assets.enabledPlugins = { logger: true };
+        prepareMock.mockResolvedValue([ctx]);
+        await run({
+            adapter: 'codex',
+            cwd: ctx.cwd,
+            env: {}
+        }, {
+            type: 'create',
+            runtime: 'server',
+            sessionId: 'session-assets',
+            promptAssetIds: ['skill:.ai/skills/research/SKILL.md'],
+            onEvent: vi.fn()
+        });
+        expect(queryMock).toHaveBeenCalledTimes(1);
+        expect(queryMock.mock.calls[0]?.[1]).toMatchObject({
+            assetPlan: {
+                adapter: 'codex',
+                diagnostics: expect.arrayContaining([
+                    expect.objectContaining({
+                        assetId: 'skill:.ai/skills/research/SKILL.md',
+                        status: 'prompt'
+                    }),
+                    expect.objectContaining({
+                        assetId: 'nativePlugin:claude-code:logger',
+                        status: 'skipped'
+                    })
+                ])
+            }
+        });
+    });
+    it('disables overlapping bridge events when claude native hooks are active', async () => {
+        const ctx = createCtx();
+        ctx.env.__VF_PROJECT_AI_CLAUDE_NATIVE_HOOKS_AVAILABLE__ = '1';
+        ctx.configs = [{
+                adapters: createAdapters({
+                    'claude-code': {}
+                })
+            }, undefined];
+        prepareMock.mockResolvedValue([ctx]);
+        await run({
+            adapter: 'claude-code',
+            cwd: ctx.cwd,
+            env: {}
+        }, {
+            type: 'create',
+            runtime: 'cli',
+            sessionId: 'session-claude-native',
+            description: 'hello',
+            onEvent: vi.fn()
+        });
+        expect(createAdapterHookBridgeMock).toHaveBeenCalledWith(expect.objectContaining({
+            adapter: 'claude-code',
+            disabledEvents: ['SessionStart', 'UserPromptSubmit', 'PreToolUse', 'PostToolUse', 'Stop']
+        }));
+    });
+    it('disables only native opencode hook events when the managed plugin bridge is active', async () => {
+        const ctx = createCtx();
+        ctx.env.__VF_PROJECT_AI_OPENCODE_NATIVE_HOOKS_AVAILABLE__ = '1';
+        ctx.configs = [{
+                adapters: createAdapters({
+                    opencode: {}
+                })
+            }, undefined];
+        prepareMock.mockResolvedValue([ctx]);
+        await run({
+            adapter: 'opencode',
+            cwd: ctx.cwd,
+            env: {}
+        }, {
+            type: 'create',
+            runtime: 'cli',
+            sessionId: 'session-opencode-native',
+            description: 'hello',
+            onEvent: vi.fn()
+        });
+        expect(createAdapterHookBridgeMock).toHaveBeenCalledWith(expect.objectContaining({
+            adapter: 'opencode',
+            disabledEvents: ['SessionStart', 'PreToolUse', 'PostToolUse', 'Stop']
+        }));
+    });
+    it('prefers exact model selector metadata over service metadata for default adapter resolution', async () => {
+        const ctx = createCtx();
+        ctx.configs = [{
+                adapters: createAdapters({
+                    codex: {},
+                    'claude-code': {}
+                }),
+                models: {
+                    serviceA: {
+                        defaultAdapter: 'claude-code'
+                    },
+                    'serviceA,modelX': {
+                        defaultAdapter: 'codex'
+                    }
+                },
+                modelServices: {
+                    serviceA: {
+                        apiBaseUrl: 'https://service-a.example.com',
+                        apiKey: 'token-a',
+                        models: ['modelX']
+                    }
+                },
+                defaultModelService: 'serviceA',
+                defaultModel: 'modelX'
+            }, undefined];
+        prepareMock.mockResolvedValue([ctx]);
+        await run({
+            cwd: ctx.cwd,
+            env: {}
+        }, {
+            type: 'create',
+            runtime: 'cli',
+            sessionId: 'session-model-selector',
+            onEvent: vi.fn()
+        });
+        expect(loadAdapterMock).toHaveBeenCalledWith('codex');
+        expect(queryMock.mock.calls[0]?.[1]).toMatchObject({
+            model: 'serviceA,modelX'
+        });
+    });
+    it('uses adapter-level defaultModel before falling back to global default model', async () => {
+        const ctx = createCtx();
+        ctx.configs = [{
+                adapters: createAdapters({
+                    codex: {
+                        defaultModel: 'serviceA,modelB'
+                    },
+                    'claude-code': {}
+                }),
+                defaultModel: 'serviceA,modelA',
+                modelServices: {
+                    serviceA: {
+                        apiBaseUrl: 'https://service-a.example.com',
+                        apiKey: 'token-a',
+                        models: ['modelA', 'modelB']
+                    }
+                }
+            }, undefined];
+        prepareMock.mockResolvedValue([ctx]);
+        await run({
+            adapter: 'codex',
+            cwd: ctx.cwd,
+            env: {}
+        }, {
+            type: 'create',
+            runtime: 'cli',
+            sessionId: 'session-adapter-model',
+            onEvent: vi.fn()
+        });
+        expect(queryMock.mock.calls[0]?.[1]).toMatchObject({
+            model: 'serviceA,modelB'
+        });
+    });
+    it('falls back to adapter defaultModel and emits a selection warning when rules reject the chosen model', async () => {
+        const ctx = createCtx();
+        const onEvent = vi.fn();
+        queryMock.mockImplementation(async (_ctx, options) => {
+            options.onEvent({
+                type: 'init',
+                data: {
+                    uuid: 'adapter-init',
+                    model: options.model ?? 'serviceA,modelA',
+                    version: '1.0.0',
+                    tools: [],
+                    slashCommands: [],
+                    cwd: '/tmp/project',
+                    agents: []
+                }
+            });
+            return {
+                kill: vi.fn(),
+                emit: vi.fn()
+            };
+        });
+        ctx.configs = [{
+                adapters: createAdapters({
+                    codex: {
+                        defaultModel: 'serviceA,modelB',
+                        excludeModels: ['serviceA,modelA']
+                    }
+                }),
+                modelServices: {
+                    serviceA: {
+                        apiBaseUrl: 'https://service-a.example.com',
+                        apiKey: 'token-a',
+                        models: ['modelA', 'modelB']
+                    }
+                }
+            }, undefined];
+        prepareMock.mockResolvedValue([ctx]);
+        await run({
+            adapter: 'codex',
+            cwd: ctx.cwd,
+            env: {}
+        }, {
+            type: 'create',
+            runtime: 'cli',
+            sessionId: 'session-adapter-model-rules',
+            model: 'serviceA,modelA',
+            onEvent
+        });
+        expect(queryMock.mock.calls[0]?.[1]).toMatchObject({
+            model: 'serviceA,modelB'
+        });
+        expect(onEvent).toHaveBeenCalledWith(expect.objectContaining({
+            type: 'init',
+            data: expect.objectContaining({
+                selectionWarnings: [
+                    expect.objectContaining({
+                        adapter: 'codex',
+                        requestedModel: 'serviceA,modelA',
+                        resolvedModel: 'serviceA,modelB',
+                        reason: 'excluded'
+                    })
+                ]
+            })
+        }));
+    });
+    it('allows the literal default model even when includeModels is configured', async () => {
+        const ctx = createCtx();
+        ctx.configs = [{
+                adapters: createAdapters({
+                    opencode: {
+                        includeModels: ['serviceA']
+                    }
+                }),
+                modelServices: {
+                    serviceA: {
+                        apiBaseUrl: 'https://service-a.example.com',
+                        apiKey: 'token-a',
+                        models: ['modelA']
+                    }
+                }
+            }, undefined];
+        prepareMock.mockResolvedValue([ctx]);
+        await run({
+            adapter: 'opencode',
+            cwd: ctx.cwd,
+            env: {}
+        }, {
+            type: 'create',
+            runtime: 'cli',
+            sessionId: 'session-default-model-allowed',
+            model: 'default',
+            onEvent: vi.fn()
+        });
+        expect(queryMock.mock.calls[0]?.[1]).toMatchObject({
+            model: 'default'
+        });
+    });
+    it('throws when adapter rules reject the selected model and defaultModel is missing', async () => {
+        const ctx = createCtx();
+        ctx.configs = [{
+                adapters: createAdapters({
+                    codex: {
+                        includeModels: ['serviceB']
+                    }
+                }),
+                modelServices: {
+                    serviceA: {
+                        apiBaseUrl: 'https://service-a.example.com',
+                        apiKey: 'token-a',
+                        models: ['modelA']
+                    },
+                    serviceB: {
+                        apiBaseUrl: 'https://service-b.example.com',
+                        apiKey: 'token-b',
+                        models: ['modelB']
+                    }
+                }
+            }, undefined];
+        prepareMock.mockResolvedValue([ctx]);
+        await expect(run({
+            adapter: 'codex',
+            cwd: ctx.cwd,
+            env: {}
+        }, {
+            type: 'create',
+            runtime: 'cli',
+            sessionId: 'session-adapter-model-rules-error',
+            model: 'serviceA,modelA',
+            onEvent: vi.fn()
+        })).rejects.toThrow('Configure adapters.codex.defaultModel to continue');
+    });
+    it('prefers user config model selector metadata over project config', async () => {
+        const ctx = createCtx();
+        ctx.configs = [{
+                adapters: createAdapters({
+                    codex: {},
+                    'claude-code': {}
+                }),
+                models: {
+                    serviceA: {
+                        defaultAdapter: 'claude-code'
+                    }
+                },
+                modelServices: {
+                    serviceA: {
+                        apiBaseUrl: 'https://service-a.example.com',
+                        apiKey: 'token-a',
+                        models: ['modelX']
+                    }
+                },
+                defaultModelService: 'serviceA',
+                defaultModel: 'modelX'
+            }, {
+                models: {
+                    serviceA: {
+                        defaultAdapter: 'codex'
+                    }
+                }
+            }];
+        prepareMock.mockResolvedValue([ctx]);
+        await run({
+            cwd: ctx.cwd,
+            env: {}
+        }, {
+            type: 'create',
+            runtime: 'cli',
+            sessionId: 'session-user-override',
+            onEvent: vi.fn()
+        });
+        expect(loadAdapterMock).toHaveBeenCalledWith('codex');
+    });
+});

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

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

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

@@ -0,0 +1,189 @@
+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 { buildAdapterAssetPlan, resolvePromptAssetSelection, resolveWorkspaceAssetBundle } from '#~/utils/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]
+        });
+        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]
+        });
+        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]
+        });
+        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]
+        });
+        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/core/src/adapter/index.d.ts

@@ -0,0 +1,4 @@
+import type { Adapter } from './type';
+export * from './loader';
+export * from './type';
+export declare const defineAdapter: <T extends Adapter>(adapter: T) => Adapter;

package/dist/packages/core/src/adapter/index.js

@@ -0,0 +1,3 @@
+export * from './loader';
+export * from './type';
+export const defineAdapter = (adapter) => adapter;

package/dist/packages/core/src/adapter/loader.d.ts

@@ -0,0 +1,2 @@
+import type { Adapter } from './type';
+export declare const loadAdapter: (type: string) => Promise<Adapter>;

package/dist/packages/core/src/adapter/loader.js

@@ -0,0 +1,4 @@
+const resolveAdapterPackageName = (type) => (type.startsWith('@') ? type : `@vibe-forge/adapter-${type}`);
+export const loadAdapter = async (type) => (
+// eslint-disable-next-line ts/no-require-imports
+require(resolveAdapterPackageName(type))).default;