@vibe-forge/tsconfigs 0.7.2 → 0.9.0

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

@@ -0,0 +1,469 @@
+import { PassThrough } from 'node:stream';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { run } from '#~/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('#~/prepare.js', () => ({
+    prepare: prepareMock
+}));
+vi.mock('@vibe-forge/types', () => ({
+    loadAdapter: loadAdapterMock
+}));
+vi.mock('@vibe-forge/hooks', () => ({
+    callHook: callHookMock,
+    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/task/src/generate-adapter-query-options.d.ts

@@ -0,0 +1,4 @@
+import type { AdapterQueryOptions } from '@vibe-forge/types';
+export declare function generateAdapterQueryOptions(type: 'spec' | 'entity' | undefined, name?: string, cwd?: string, input?: {
+    skills?: AdapterQueryOptions['skills'];
+}): Promise<readonly [import("@vibe-forge/types").PromptAssetResolution, Partial<AdapterQueryOptions>]>;

package/dist/packages/task/src/generate-adapter-query-options.js

@@ -0,0 +1,15 @@
+import process from 'node:process';
+import { resolvePromptAssetSelection, resolveWorkspaceAssetBundle } from '@vibe-forge/workspace-assets';
+export async function generateAdapterQueryOptions(type, name, cwd = process.cwd(), input) {
+    const bundle = await resolveWorkspaceAssetBundle({ cwd });
+    const [data, resolvedOptions] = await resolvePromptAssetSelection({
+        bundle,
+        type,
+        name,
+        input
+    });
+    return [
+        data,
+        resolvedOptions
+    ];
+}

package/dist/packages/task/src/index.d.ts

@@ -0,0 +1,3 @@
+export { generateAdapterQueryOptions } from '#~/generate-adapter-query-options.js';
+export { run } from '#~/run.js';
+export type { RunTaskOptions } from '#~/type.js';

package/dist/packages/task/src/index.js

@@ -0,0 +1,2 @@
+export { generateAdapterQueryOptions } from '#~/generate-adapter-query-options.js';
+export { run } from '#~/run.js';

package/dist/packages/task/src/prepare.d.ts

@@ -0,0 +1,16 @@
+import type { AdapterQueryOptions, Config } from '@vibe-forge/types';
+import type { RunTaskOptions } from '#~/type.js';
+export declare const prepare: (options: RunTaskOptions, adapterOptions: AdapterQueryOptions) => Promise<readonly [{
+    ctxId: string;
+    cwd: string;
+    env: Record<string, string | null | undefined>;
+    cache: {
+        set: <K extends keyof import("@vibe-forge/types").Cache>(key: K, value: import("@vibe-forge/types").Cache[K]) => Promise<{
+            cachePath: string;
+        }>;
+        get: <K extends keyof import("@vibe-forge/types").Cache>(key: K) => Promise<import("@vibe-forge/types").Cache[K] | undefined>;
+    };
+    logger: import("@vibe-forge/types").Logger;
+    configs: [Config | undefined, Config | undefined];
+    assets: import("@vibe-forge/types").WorkspaceAssetBundle;
+}]>;

package/dist/packages/task/src/prepare.js

@@ -0,0 +1,50 @@
+import process from 'node:process';
+import { buildConfigJsonVariables, loadConfig, resolveUseDefaultVibeForgeMcpServer } from '@vibe-forge/config';
+import { resolveWorkspaceAssetBundle } from '@vibe-forge/workspace-assets';
+import { getCache, setCache } from '@vibe-forge/utils/cache';
+import { createLogger } from '@vibe-forge/utils/create-logger';
+import { resolveServerLogLevel } from '@vibe-forge/utils/log-level';
+import { uuid } from '@vibe-forge/utils/uuid';
+export const prepare = async (options, adapterOptions) => {
+    const cwd = options.cwd ?? process.env.__VF_PROJECT_WORKSPACE_FOLDER__ ?? process.cwd();
+    const { sessionId = uuid() } = adapterOptions;
+    const { ctxId = process.env.__VF_PROJECT_AI_CTX_ID__ ?? sessionId, env: envFromOptions } = options;
+    const { __IS_LOADER_CLI__: _0, ...prevEnv } = {
+        ...process.env,
+        ...envFromOptions
+    };
+    const env = {
+        ...prevEnv,
+        __VF_PROJECT_AI_CTX_ID__: ctxId,
+        __VF_PROJECT_AI_SESSION_ID__: sessionId,
+        __VF_PROJECT_AI_RUN_TYPE__: adapterOptions.runtime,
+        // 移除 NODE_OPTIONS 环境变量，防止干扰子进程的运行环境
+        NODE_OPTIONS: undefined
+    };
+    const logger = createLogger(cwd, ctxId, sessionId, env?.LOG_PREFIX ?? '', resolveServerLogLevel(env));
+    const jsonVariables = buildConfigJsonVariables(cwd, env);
+    const [config, userConfig] = await loadConfig({ cwd, jsonVariables });
+    const assets = await resolveWorkspaceAssetBundle({
+        cwd,
+        configs: [config, userConfig],
+        useDefaultVibeForgeMcpServer: resolveUseDefaultVibeForgeMcpServer({
+            runtimeValue: adapterOptions.useDefaultVibeForgeMcpServer,
+            projectConfig: config,
+            userConfig
+        })
+    });
+    return [
+        {
+            ctxId,
+            cwd,
+            env,
+            cache: {
+                set: (key, value) => setCache(cwd, ctxId, sessionId, key, value),
+                get: (key) => getCache(cwd, ctxId, sessionId, key)
+            },
+            logger,
+            configs: [config, userConfig],
+            assets
+        }
+    ];
+};

package/dist/packages/task/src/run.d.ts

@@ -0,0 +1,25 @@
+import type { AdapterCtx, AdapterQueryOptions, TaskDetail } from '@vibe-forge/types';
+import type { RunTaskOptions } from '#~/type.js';
+declare module '@vibe-forge/types' {
+    interface Cache {
+        base: Omit<AdapterCtx, 'logger' | 'cache'>;
+        detail: TaskDetail;
+    }
+}
+export declare const run: (options: RunTaskOptions, adapterOptions: AdapterQueryOptions) => Promise<{
+    session: import("@vibe-forge/hooks").HookBridgeSession;
+    ctx: {
+        ctxId: string;
+        cwd: string;
+        env: Record<string, string | null | undefined>;
+        cache: {
+            set: <K extends keyof import("@vibe-forge/types").Cache>(key: K, value: import("@vibe-forge/types").Cache[K]) => Promise<{
+                cachePath: string;
+            }>;
+            get: <K extends keyof import("@vibe-forge/types").Cache>(key: K) => Promise<import("@vibe-forge/types").Cache[K] | undefined>;
+        };
+        logger: import("@vibe-forge/types").Logger;
+        configs: [import("@vibe-forge/types").Config | undefined, import("@vibe-forge/types").Config | undefined];
+        assets: import("@vibe-forge/types").WorkspaceAssetBundle;
+    };
+}>;