@vibe-forge/tsconfigs 0.7.2 → 0.8.0

package/dist/scripts/adapter-e2e/runners.js

@@ -0,0 +1,172 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runOpenCode = exports.runOpenCodeUpstream = exports.runWrappedAdapter = void 0;
+const node_process_1 = __importDefault(require("node:process"));
+const promises_1 = require("node:fs/promises");
+const node_path_1 = __importDefault(require("node:path"));
+const runtime_1 = require("./runtime");
+const verify_1 = require("./verify");
+const isCodexTransientEntry = (name) => (name === '.tmp' ||
+    name === 'history.jsonl' ||
+    name === 'log' ||
+    name === 'shell_snapshots' ||
+    /^logs_\d+\.sqlite(?:-(?:shm|wal))?$/.test(name) ||
+    /^state_\d+\.sqlite(?:-(?:shm|wal))?$/.test(name));
+const resetCodexMockState = async () => {
+    const codexHome = node_path_1.default.resolve(runtime_1.mockHome, '.codex');
+    const entries = await (0, promises_1.readdir)(codexHome, { withFileTypes: true }).catch(() => []);
+    await Promise.all(entries
+        .filter(entry => isCodexTransientEntry(entry.name))
+        .map(entry => (0, promises_1.rm)(node_path_1.default.resolve(codexHome, entry.name), {
+        force: true,
+        recursive: true
+    })));
+};
+const runWrappedAdapter = async (testCase, mockServerPort, options) => {
+    const ctxId = (0, runtime_1.createCtxId)(testCase.adapter);
+    const sessionId = (0, runtime_1.createSessionId)();
+    if (testCase.adapter === 'codex') {
+        await resetCodexMockState();
+    }
+    const result = await (0, runtime_1.runProcess)({
+        command: node_process_1.default.execPath,
+        args: testCase.args(sessionId),
+        env: (0, runtime_1.buildBaseEnv)(ctxId, mockServerPort),
+        timeoutMs: Number(node_process_1.default.env.HOOK_SMOKE_TIMEOUT_MS ?? 180_000),
+        passthroughStdIO: options.passthroughStdIO ?? true
+    });
+    if (result.code !== 0) {
+        throw new Error(`${testCase.adapter} smoke exited with code ${result.code}`);
+    }
+    const { logPath, content } = await (0, verify_1.readHookLog)({
+        ctxId,
+        sessionId
+    });
+    return {
+        caseId: testCase.id,
+        adapter: testCase.adapter,
+        ctxId,
+        sessionId,
+        logPath,
+        logContent: content,
+        managedArtifacts: await (0, verify_1.collectManagedArtifacts)({
+            adapter: testCase.adapter,
+            sessionId
+        }),
+        stdout: result.stdout,
+        stderr: result.stderr,
+        exitCode: result.code,
+        transport: 'wrapper',
+        mockTrace: []
+    };
+};
+exports.runWrappedAdapter = runWrappedAdapter;
+const runOpenCodeUpstream = async (input) => {
+    const configDir = `${runtime_1.repoRoot}/.ai/.mock/.opencode-adapter/${input.sessionId}/config-dir`;
+    if (!await (0, runtime_1.waitForPath)(configDir, 5_000)) {
+        throw new Error(`OpenCode config dir not found for fallback: ${configDir}`);
+    }
+    const result = await (0, runtime_1.runProcess)({
+        command: runtime_1.opencodeBin,
+        args: [
+            'run',
+            '--print-logs',
+            '--format',
+            'json',
+            '--model',
+            (0, runtime_1.toProviderModel)(input.testCase.model),
+            '--dir',
+            runtime_1.repoRoot,
+            input.testCase.prompt
+        ],
+        env: {
+            ...(0, runtime_1.buildBaseEnv)(input.ctxId, input.mockServerPort),
+            HOME: runtime_1.mockHome,
+            OPENCODE_CONFIG_DIR: configDir,
+            __VF_VIBE_FORGE_OPENCODE_HOOKS_ACTIVE__: '1',
+            __VF_PROJECT_NODE_PATH__: node_process_1.default.execPath,
+            __VF_PROJECT_REAL_HOME__: runtime_1.realHome,
+            __VF_PROJECT_CLI_PACKAGE_DIR__: runtime_1.cliPackageDir,
+            __VF_PROJECT_PACKAGE_DIR__: runtime_1.cliPackageDir,
+            __VF_OPENCODE_TASK_SESSION_ID__: input.sessionId,
+            __VF_OPENCODE_HOOK_RUNTIME__: 'cli'
+        },
+        timeoutMs: Number(node_process_1.default.env.HOOK_SMOKE_TIMEOUT_MS ?? 180_000),
+        passthroughStdIO: input.passthroughStdIO
+    });
+    if (result.code !== 0) {
+        throw new Error(`opencode upstream smoke exited with code ${result.code}`);
+    }
+    const { logPath, content } = await (0, verify_1.readHookLog)({
+        ctxId: input.ctxId,
+        sessionId: input.sessionId
+    });
+    return {
+        caseId: input.testCase.id,
+        adapter: 'opencode',
+        ctxId: input.ctxId,
+        sessionId: input.sessionId,
+        logPath,
+        logContent: content,
+        managedArtifacts: await (0, verify_1.collectManagedArtifacts)({
+            adapter: 'opencode',
+            sessionId: input.sessionId
+        }),
+        stdout: result.stdout,
+        stderr: result.stderr,
+        exitCode: result.code,
+        transport: 'upstream-fallback',
+        mockTrace: []
+    };
+};
+exports.runOpenCodeUpstream = runOpenCodeUpstream;
+const runOpenCode = async (testCase, mockServerPort, options) => {
+    const ctxId = (0, runtime_1.createCtxId)('opencode');
+    const sessionId = (0, runtime_1.createSessionId)();
+    const wrapperTimeoutMs = Number(node_process_1.default.env.HOOK_SMOKE_OPENCODE_WRAPPER_TIMEOUT_MS ?? 20_000);
+    const wrapperResult = await (0, runtime_1.runProcess)({
+        command: node_process_1.default.execPath,
+        args: testCase.args(sessionId),
+        env: (0, runtime_1.buildBaseEnv)(ctxId, mockServerPort),
+        timeoutMs: wrapperTimeoutMs,
+        passthroughStdIO: options.passthroughStdIO ?? true
+    });
+    if (wrapperResult.code === 0 &&
+        !wrapperResult.timedOut) {
+        const { logPath, content } = await (0, verify_1.readHookLog)({
+            ctxId,
+            sessionId
+        });
+        return {
+            caseId: testCase.id,
+            adapter: 'opencode',
+            ctxId,
+            sessionId,
+            logPath,
+            logContent: content,
+            managedArtifacts: await (0, verify_1.collectManagedArtifacts)({
+                adapter: 'opencode',
+                sessionId
+            }),
+            stdout: wrapperResult.stdout,
+            stderr: wrapperResult.stderr,
+            exitCode: wrapperResult.code,
+            transport: 'wrapper',
+            mockTrace: []
+        };
+    }
+    if (options.passthroughStdIO ?? true) {
+        console.warn('\n[smoke:opencode] wrapper path did not complete cleanly, falling back to upstream CLI');
+    }
+    return (0, exports.runOpenCodeUpstream)({
+        testCase,
+        ctxId,
+        sessionId,
+        mockServerPort,
+        passthroughStdIO: options.passthroughStdIO ?? true
+    });
+};
+exports.runOpenCode = runOpenCode;

package/dist/scripts/adapter-e2e/runtime.d.ts

@@ -0,0 +1,18 @@
+import type { RunProcessOptions, RunProcessResult } from './types';
+export declare const repoRoot: string;
+export declare const cliPath: string;
+export declare const cliPackageDir: string;
+export declare const opencodeBin: string;
+export declare const mockHome: string;
+export declare const realHome: string;
+export declare const mockModelService = "hook-smoke-mock";
+export declare const mockClaudeService = "hook-smoke-mock-ccr";
+export declare const isDebugEnabled: boolean;
+export declare const createCtxId: (adapter: string) => string;
+export declare const createSessionId: () => string;
+export declare const toProviderModel: (model: string) => string;
+export declare const sleep: (ms: number) => Promise<unknown>;
+export declare const pathExists: (targetPath: string) => Promise<boolean>;
+export declare const waitForPath: (targetPath: string, timeoutMs?: number) => Promise<boolean>;
+export declare const runProcess: ({ command, args, env, timeoutMs, passthroughStdIO }: RunProcessOptions) => Promise<RunProcessResult>;
+export declare const buildBaseEnv: (ctxId: string, mockServerPort: number) => NodeJS.ProcessEnv;

package/dist/scripts/adapter-e2e/runtime.js

@@ -0,0 +1,127 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildBaseEnv = exports.runProcess = exports.waitForPath = exports.pathExists = exports.sleep = exports.toProviderModel = exports.createSessionId = exports.createCtxId = exports.isDebugEnabled = exports.mockClaudeService = exports.mockModelService = exports.realHome = exports.mockHome = exports.opencodeBin = exports.cliPackageDir = exports.cliPath = exports.repoRoot = void 0;
+const node_buffer_1 = require("node:buffer");
+const node_child_process_1 = require("node:child_process");
+const node_crypto_1 = require("node:crypto");
+const promises_1 = require("node:fs/promises");
+const node_path_1 = __importDefault(require("node:path"));
+const node_process_1 = __importDefault(require("node:process"));
+exports.repoRoot = node_process_1.default.cwd();
+exports.cliPath = node_path_1.default.resolve(exports.repoRoot, 'apps/cli/cli.js');
+exports.cliPackageDir = node_path_1.default.resolve(exports.repoRoot, 'apps/cli');
+exports.opencodeBin = node_path_1.default.resolve(exports.repoRoot, 'packages/adapters/opencode/node_modules/.bin/opencode');
+exports.mockHome = node_path_1.default.resolve(exports.repoRoot, '.ai/.mock');
+exports.realHome = node_process_1.default.env.HOME ?? '';
+exports.mockModelService = 'hook-smoke-mock';
+exports.mockClaudeService = 'hook-smoke-mock-ccr';
+exports.isDebugEnabled = node_process_1.default.env.HOOK_SMOKE_DEBUG === '1';
+const createCtxId = (adapter) => (node_process_1.default.env.HOOK_SMOKE_CTX_ID?.trim() || `hooks-smoke-${adapter}-${Date.now()}`);
+exports.createCtxId = createCtxId;
+const createSessionId = () => (node_process_1.default.env.HOOK_SMOKE_SESSION_ID?.trim() || (0, node_crypto_1.randomUUID)());
+exports.createSessionId = createSessionId;
+const toProviderModel = (model) => {
+    if (!model.includes(','))
+        return model;
+    const [providerId, modelId] = model.split(',', 2);
+    return `${providerId}/${modelId}`;
+};
+exports.toProviderModel = toProviderModel;
+const sleep = (ms) => new Promise(resolve => setTimeout(resolve, ms));
+exports.sleep = sleep;
+const pathExists = async (targetPath) => {
+    try {
+        await (0, promises_1.access)(targetPath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+};
+exports.pathExists = pathExists;
+const waitForPath = async (targetPath, timeoutMs = 5_000) => {
+    const startedAt = Date.now();
+    while (Date.now() - startedAt < timeoutMs) {
+        if (await (0, exports.pathExists)(targetPath))
+            return true;
+        await (0, exports.sleep)(200);
+    }
+    return false;
+};
+exports.waitForPath = waitForPath;
+const killProcessTree = (pid, signal) => {
+    if (pid == null)
+        return;
+    try {
+        if (node_process_1.default.platform !== 'win32') {
+            node_process_1.default.kill(-pid, signal);
+            return;
+        }
+    }
+    catch {
+    }
+    try {
+        node_process_1.default.kill(pid, signal);
+    }
+    catch {
+    }
+};
+const runProcess = async ({ command, args, env, timeoutMs, passthroughStdIO = true }) => {
+    const child = (0, node_child_process_1.spawn)(command, args, {
+        cwd: exports.repoRoot,
+        env,
+        detached: node_process_1.default.platform !== 'win32',
+        stdio: ['ignore', 'pipe', 'pipe']
+    });
+    const stdoutChunks = [];
+    const stderrChunks = [];
+    let timedOut = false;
+    let forceKillTimer;
+    child.stdout.on('data', (chunk) => {
+        stdoutChunks.push(chunk);
+        if (passthroughStdIO)
+            node_process_1.default.stdout.write(chunk);
+    });
+    child.stderr.on('data', (chunk) => {
+        stderrChunks.push(chunk);
+        if (passthroughStdIO)
+            node_process_1.default.stderr.write(chunk);
+    });
+    const timeout = timeoutMs != null
+        ? setTimeout(() => {
+            timedOut = true;
+            killProcessTree(child.pid ?? undefined, 'SIGTERM');
+            forceKillTimer = setTimeout(() => {
+                killProcessTree(child.pid ?? undefined, 'SIGKILL');
+            }, 5_000);
+        }, timeoutMs)
+        : undefined;
+    return new Promise((resolve, reject) => {
+        child.once('error', reject);
+        child.once('close', (code, signal) => {
+            if (timeout != null)
+                clearTimeout(timeout);
+            if (forceKillTimer != null)
+                clearTimeout(forceKillTimer);
+            resolve({
+                code: code ?? (timedOut ? -1 : 0),
+                signal,
+                timedOut,
+                stdout: node_buffer_1.Buffer.concat(stdoutChunks).toString('utf8'),
+                stderr: node_buffer_1.Buffer.concat(stderrChunks).toString('utf8')
+            });
+        });
+    });
+};
+exports.runProcess = runProcess;
+const buildBaseEnv = (ctxId, mockServerPort) => ({
+    ...node_process_1.default.env,
+    __VF_PROJECT_AI_CTX_ID__: ctxId,
+    __VF_PROJECT_AI_DISABLE_DEV_CONFIG__: '1',
+    __VF_PROJECT_WORKSPACE_FOLDER__: exports.repoRoot,
+    HOOK_SMOKE_MOCK_PORT: String(mockServerPort)
+});
+exports.buildBaseEnv = buildBaseEnv;

package/dist/scripts/adapter-e2e/scenarios.d.ts

@@ -0,0 +1,8 @@
+import type { AdapterE2ETarget, ManagedArtifactDefinition } from './types';
+export declare const ADAPTER_E2E_TARGETS: AdapterE2ETarget[];
+export declare const ADAPTER_E2E_DEFAULTS: Record<AdapterE2ETarget, {
+    finalOutput: string;
+    model: string;
+    prompt: string;
+}>;
+export declare const MANAGED_ARTIFACTS: Record<AdapterE2ETarget, ManagedArtifactDefinition[]>;

package/dist/scripts/adapter-e2e/scenarios.js

@@ -0,0 +1,86 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MANAGED_ARTIFACTS = exports.ADAPTER_E2E_DEFAULTS = exports.ADAPTER_E2E_TARGETS = void 0;
+const node_path_1 = __importDefault(require("node:path"));
+const runtime_1 = require("./runtime");
+const codexPrompt = 'Use the Read tool exactly once on README.md, then reply with exactly E2E_CODEX and nothing else.';
+const claudePrompt = 'Use the Read tool exactly once on README.md, then reply with exactly E2E_CLAUDE and nothing else.';
+const opencodePrompt = 'Use the read tool exactly once on README.md, then reply with exactly E2E_OPENCODE and nothing else.';
+exports.ADAPTER_E2E_TARGETS = [
+    'codex',
+    'claude-code',
+    'opencode'
+];
+exports.ADAPTER_E2E_DEFAULTS = {
+    codex: {
+        finalOutput: 'E2E_CODEX',
+        model: `${runtime_1.mockModelService},codex-hooks`,
+        prompt: codexPrompt
+    },
+    'claude-code': {
+        finalOutput: 'E2E_CLAUDE',
+        model: `${runtime_1.mockClaudeService},claude-hooks`,
+        prompt: claudePrompt
+    },
+    opencode: {
+        finalOutput: 'E2E_OPENCODE',
+        model: `${runtime_1.mockModelService},opencode-hooks`,
+        prompt: opencodePrompt
+    }
+};
+exports.MANAGED_ARTIFACTS = {
+    codex: [
+        {
+            label: 'codex hooks config',
+            candidates: [
+                {
+                    path: node_path_1.default.resolve(runtime_1.repoRoot, '.ai/.mock/.codex/hooks.json'),
+                    includes: ['call-hook.js', 'PreToolUse', 'PostToolUse', 'SessionStart', 'UserPromptSubmit', 'Stop']
+                }
+            ]
+        }
+    ],
+    'claude-code': [
+        {
+            label: 'claude managed settings',
+            candidates: [
+                {
+                    path: node_path_1.default.resolve(runtime_1.repoRoot, '.ai/.mock/.claude/settings.json'),
+                    includes: ['"hooks"']
+                }
+            ]
+        }
+    ],
+    opencode: [
+        {
+            label: 'opencode global config',
+            candidates: [
+                {
+                    path: node_path_1.default.resolve(runtime_1.repoRoot, '.ai/.mock/.config/opencode/opencode.json'),
+                    includes: ['https://opencode.ai/config.json']
+                }
+            ]
+        },
+        {
+            label: 'opencode managed plugin',
+            candidates: [
+                {
+                    path: node_path_1.default.resolve(runtime_1.repoRoot, '.ai/.mock/.config/opencode/plugins/vibe-forge-hooks.js'),
+                    includes: ['VibeForgeHooks', 'call-hook.js', 'tool.execute.before', 'tool.execute.after']
+                }
+            ]
+        },
+        {
+            label: 'opencode session config',
+            candidates: [
+                {
+                    path: node_path_1.default.resolve(runtime_1.repoRoot, '.ai/.mock/.opencode-adapter', ':sessionId', 'config-dir', 'opencode.json'),
+                    includes: ['"provider"', 'hook-smoke-mock']
+                }
+            ]
+        }
+    ]
+};

package/dist/scripts/adapter-e2e/snapshot.d.ts

@@ -0,0 +1,46 @@
+import type { AdapterE2EResult } from './types';
+export declare const createAdapterE2ESnapshot: (result: AdapterE2EResult) => {
+    caseId: string;
+    adapter: import("./types").AdapterE2ETarget;
+    transport: import("./types").AdapterTransport;
+    exitCode: number;
+    stdout: string | {
+        [k: string]: unknown;
+    }[];
+    stderr: string | string[];
+    mockTrace: {
+        path: string;
+        model: string;
+        request: string;
+        inputTypes: string[];
+        requestedToolCount: number;
+        selectedTool: {
+            name: string;
+            args: unknown;
+        } | undefined;
+        response: {
+            kind: string;
+            tool: {
+                name: string;
+                args: unknown;
+            };
+            text?: undefined;
+        } | {
+            kind: string;
+            text: string;
+            tool?: undefined;
+        };
+    }[];
+    log: {
+        path: string;
+        entries: {
+            [k: string]: unknown;
+        }[];
+    };
+    artifacts: {
+        label: string;
+        path: string;
+        content: string;
+    }[];
+};
+export declare const serializeAdapterE2ESnapshot: (result: AdapterE2EResult) => string;