@vibe-forge/tsconfigs 0.7.2 → 0.8.0

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

@@ -0,0 +1,289 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.serializeAdapterE2ESnapshot = exports.createAdapterE2ESnapshot = void 0;
+const node_path_1 = __importDefault(require("node:path"));
+const node_process_1 = __importDefault(require("node:process"));
+const log_1 = require("./log");
+const runtime_1 = require("./runtime");
+const uuidPattern = /\b[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\b/gi;
+const sanitizeValue = (value) => (value
+    .replaceAll(runtime_1.repoRoot, '<repo>')
+    .replaceAll(node_process_1.default.execPath, '<node-path>')
+    .replace(uuidPattern, '<uuid>')
+    .replace(/hooks-smoke-[\w-]+-\d+/g, '<ctxId>')
+    .replace(/\.tmp-\d+/g, '.tmp-<nonce>')
+    .replace(/http:\/\/127\.0\.0\.1:\d+/g, 'http://127.0.0.1:<port>')
+    .replace(/hook-smoke-local/g, '<mock-api-key>')
+    .replace(/\b(?:ses|msg|prt|call|resp|chatcmpl)_[\w-]+\b/g, '<id>')
+    .replace(/\/Users\/[^/\n]+/g, '<user-home>'));
+const normalizeTextBlock = (value) => (sanitizeValue(value
+    .split('\n')
+    .map(line => line.trimEnd())
+    .join('\n')
+    .trim()));
+const summarizeText = (value, maxChars = 180) => {
+    const normalized = normalizeTextBlock(value);
+    if (normalized === '')
+        return normalized;
+    const lines = normalized
+        .split('\n')
+        .map(line => line.trim())
+        .filter(Boolean);
+    const highlighted = [...lines].reverse().find((line) => (/Generate a title|README\.md|reply with exactly|Use the|Use a tool first|E2E_/i.test(line))) ?? lines.at(-1) ?? normalized;
+    return highlighted.length > maxChars
+        ? `${highlighted.slice(0, maxChars)}...`
+        : highlighted;
+};
+const summarizeContent = (value, maxLines = 24) => {
+    const normalized = normalizeTextBlock(value);
+    if (normalized === '')
+        return normalized;
+    const lines = normalized.split('\n');
+    if (lines.length <= maxLines)
+        return normalized;
+    return [
+        ...lines.slice(0, maxLines),
+        `... (${lines.length - maxLines} more lines)`
+    ].join('\n');
+};
+const sanitizeUnknown = (value) => {
+    if (typeof value === 'string')
+        return sanitizeValue(value);
+    if (Array.isArray(value))
+        return value.map(item => sanitizeUnknown(item));
+    if (value != null && typeof value === 'object') {
+        return Object.fromEntries(Object.entries(value)
+            .sort(([left], [right]) => left.localeCompare(right))
+            .map(([key, item]) => [key, sanitizeUnknown(item)]));
+    }
+    return value;
+};
+const compactObject = (value) => (Object.fromEntries(Object.entries(value).filter(([, entry]) => (entry !== undefined &&
+    entry !== '' &&
+    (!Array.isArray(entry) || entry.length > 0)))));
+const readNested = (payload, pathKeys) => {
+    let current = payload;
+    for (const key of pathKeys) {
+        if (current == null || typeof current !== 'object' || Array.isArray(current)) {
+            return undefined;
+        }
+        current = current[key];
+    }
+    return current;
+};
+const pickNestedString = (payload, candidates) => {
+    for (const pathKeys of candidates) {
+        const current = readNested(payload, pathKeys);
+        if (typeof current === 'string' && current.trim() !== '') {
+            return sanitizeValue(current);
+        }
+    }
+    return undefined;
+};
+const pickNestedBoolean = (payload, candidates) => {
+    for (const pathKeys of candidates) {
+        const current = readNested(payload, pathKeys);
+        if (typeof current === 'boolean') {
+            return current;
+        }
+    }
+    return undefined;
+};
+const inferToolNameFromHeader = (headerText, adapter) => {
+    if (headerText == null)
+        return undefined;
+    const normalized = sanitizeValue(headerText).trim();
+    if (normalized === '')
+        return undefined;
+    if (adapter != null && normalized.startsWith(`${adapter} `)) {
+        return normalized.slice(adapter.length + 1).trim() || undefined;
+    }
+    const knownAdapterPrefix = ['codex', 'claude-code', 'opencode']
+        .find(prefix => normalized.startsWith(`${prefix} `));
+    if (knownAdapterPrefix != null) {
+        return normalized.slice(knownAdapterPrefix.length + 1).trim() || undefined;
+    }
+    return normalized;
+};
+const summarizeLog = (content) => {
+    return (0, log_1.parseHookLogEntries)(content).map((entry) => {
+        const adapter = pickNestedString(entry.payload, [['adapter']]);
+        const toolName = pickNestedString(entry.payload, [
+            ['toolName'],
+            ['tool', 'name'],
+            ['data', 'toolName'],
+            ['data', 'tool', 'name'],
+            ['input', 'toolName']
+        ]) ?? inferToolNameFromHeader(entry.headerText, adapter);
+        const detail = (() => {
+            const fromPayload = pickNestedString(entry.payload, [
+                ['command'],
+                ['toolInput', 'command'],
+                ['args', 'command'],
+                ['resp', 'title'],
+                ['data', 'message']
+            ]);
+            if (fromPayload != null)
+                return summarizeText(fromPayload);
+            if (entry.textBlock != null)
+                return summarizeText(entry.textBlock);
+            return undefined;
+        })();
+        return compactObject({
+            event: entry.eventName,
+            adapter,
+            hookSource: pickNestedString(entry.payload, [['hookSource']]),
+            canBlock: typeof entry.payload.canBlock === 'boolean' ? entry.payload.canBlock : undefined,
+            prompt: (() => {
+                const prompt = pickNestedString(entry.payload, [['prompt'], ['data', 'prompt']]);
+                return prompt == null ? undefined : summarizeText(prompt);
+            })(),
+            header: entry.headerText == null ? undefined : sanitizeValue(entry.headerText),
+            toolName,
+            detail,
+            redacted: pickNestedBoolean(entry.payload, [
+                ['options', 'env', 'redacted'],
+                ['env', 'redacted'],
+                ['data', 'env', 'redacted']
+            ])
+        });
+    });
+};
+const summarizeStdout = (stdout) => {
+    const normalized = normalizeTextBlock(stdout);
+    if (normalized === '')
+        return normalized;
+    const lines = normalized.split('\n').filter(Boolean);
+    const parsed = lines.map((line) => {
+        try {
+            return JSON.parse(line);
+        }
+        catch {
+            return undefined;
+        }
+    });
+    if (parsed.every(item => item != null)) {
+        return parsed.map((item) => {
+            const part = item?.part;
+            const partObject = (part != null &&
+                typeof part === 'object' &&
+                !Array.isArray(part))
+                ? part
+                : {};
+            const state = (partObject.state != null &&
+                typeof partObject.state === 'object' &&
+                !Array.isArray(partObject.state))
+                ? partObject.state
+                : {};
+            return compactObject({
+                type: item?.type,
+                partType: partObject.type,
+                reason: partObject.reason,
+                text: typeof partObject.text === 'string' ? summarizeText(partObject.text) : undefined,
+                tool: typeof partObject.tool === 'string' ? partObject.tool : undefined,
+                status: state.status,
+                input: state.input == null ? undefined : sanitizeUnknown(state.input)
+            });
+        });
+    }
+    return summarizeText(normalized, 240);
+};
+const summarizeStderr = (stderr) => {
+    const normalized = normalizeTextBlock(stderr);
+    if (normalized === '')
+        return normalized;
+    const lines = normalized
+        .split('\n')
+        .map((line) => line
+        .replace(/^\d{4}-\d{2}-\d{2}T\S+\s+/, '')
+        .replace(/^INFO\s+\d{4}-\d{2}-\d{2}T\S+\s+\+\d+ms\s+/, 'INFO ')
+        .replace(/^WARN\s+\d{4}-\d{2}-\d{2}T\S+\s+\+\d+ms\s+/, 'WARN ')
+        .replace(/^ERROR\s+\d{4}-\d{2}-\d{2}T\S+\s+\+\d+ms\s+/, 'ERROR ')
+        .trim());
+    const filteredLines = [];
+    let droppingHtmlNoise = false;
+    for (const line of lines) {
+        if (line === '')
+            continue;
+        if (line.includes('service=bun cmd=') || line.includes('service=bun code='))
+            continue;
+        const isStructuredLogLine = /^(?:INFO|WARN|ERROR)\s/.test(line);
+        if (line.includes('failed to warm featured plugin ids cache')) {
+            droppingHtmlNoise = true;
+            continue;
+        }
+        if (droppingHtmlNoise) {
+            if (!isStructuredLogLine) {
+                continue;
+            }
+            droppingHtmlNoise = false;
+        }
+        if (/^<\/?(?:html|head|body|meta|style|div|svg|path)\b/i.test(line)) {
+            continue;
+        }
+        if (/^[a-z]+="[^"]*"$/i.test(line)) {
+            continue;
+        }
+        if (line === '>' || line === '/>') {
+            continue;
+        }
+        filteredLines.push(line);
+    }
+    const unique = [];
+    for (const line of filteredLines) {
+        if (!unique.includes(line)) {
+            unique.push(line);
+        }
+    }
+    return unique.length > 12
+        ? [...unique.slice(0, 12), '... (truncated)']
+        : unique;
+};
+const createAdapterE2ESnapshot = (result) => ({
+    caseId: result.caseId,
+    adapter: result.adapter,
+    transport: result.transport,
+    exitCode: result.exitCode,
+    stdout: summarizeStdout(result.stdout),
+    stderr: summarizeStderr(result.stderr),
+    mockTrace: result.mockTrace.map(entry => ({
+        path: sanitizeValue(entry.path),
+        model: sanitizeValue(entry.model),
+        request: summarizeText(entry.requestText),
+        inputTypes: entry.inputTypes,
+        requestedToolCount: entry.requestedToolCount,
+        selectedTool: entry.selectedTool == null
+            ? undefined
+            : {
+                name: sanitizeValue(entry.selectedTool.name),
+                args: sanitizeUnknown(entry.selectedTool.args)
+            },
+        response: entry.response.kind === 'tool'
+            ? {
+                kind: 'tool',
+                tool: {
+                    name: sanitizeValue(entry.response.tool.name),
+                    args: sanitizeUnknown(entry.response.tool.args)
+                }
+            }
+            : {
+                kind: 'message',
+                text: summarizeText(entry.response.text)
+            }
+    })),
+    log: {
+        path: sanitizeValue(node_path_1.default.relative(runtime_1.repoRoot, result.logPath)),
+        entries: summarizeLog(result.logContent)
+    },
+    artifacts: result.managedArtifacts.map(artifact => ({
+        label: artifact.label,
+        path: sanitizeValue(node_path_1.default.relative(runtime_1.repoRoot, artifact.path)),
+        content: summarizeContent(artifact.content)
+    }))
+});
+exports.createAdapterE2ESnapshot = createAdapterE2ESnapshot;
+const serializeAdapterE2ESnapshot = (result) => (`${JSON.stringify((0, exports.createAdapterE2ESnapshot)(result), null, 2)}\n`);
+exports.serializeAdapterE2ESnapshot = serializeAdapterE2ESnapshot;

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

@@ -0,0 +1,150 @@
+export type AdapterE2ETarget = 'codex' | 'claude-code' | 'opencode';
+export type AdapterTransport = 'wrapper' | 'upstream-fallback';
+export interface AdapterE2EHookExpectation {
+    event: string;
+    count?: number;
+    minCount?: number;
+    maxCount?: number;
+}
+export interface AdapterE2EMockTraceExpectation {
+    minRequests?: number;
+    requiredToolNames?: string[];
+    maxToolCalls?: number;
+    finalResponseText?: string;
+}
+export interface AdapterE2ECaseExpectations {
+    outputContains?: string[];
+    hooks?: AdapterE2EHookExpectation[];
+    mockTrace?: AdapterE2EMockTraceExpectation;
+}
+export interface ManagedArtifactCandidate {
+    path: string;
+    includes: string[];
+}
+export interface ManagedArtifactDefinition {
+    label: string;
+    candidates: ManagedArtifactCandidate[];
+}
+export interface VerifiedManagedArtifact {
+    label: string;
+    path: string;
+    includes: string[];
+    content: string;
+}
+export interface AdapterE2EResult {
+    caseId: string;
+    adapter: AdapterE2ETarget;
+    ctxId: string;
+    sessionId: string;
+    logPath: string;
+    logContent: string;
+    managedArtifacts: VerifiedManagedArtifact[];
+    stdout: string;
+    stderr: string;
+    exitCode: number;
+    transport: AdapterTransport;
+    mockTrace: MockLlmTraceEntry[];
+}
+export interface AdapterE2EHarnessOptions {
+    passthroughStdIO?: boolean;
+    printSummary?: boolean;
+    mockServerOptions?: MockLlmServerOptions;
+    cases?: AdapterE2ECase[];
+}
+export interface RunProcessOptions {
+    command: string;
+    args: string[];
+    env: NodeJS.ProcessEnv;
+    timeoutMs?: number;
+    passthroughStdIO?: boolean;
+}
+export interface RunProcessResult {
+    code: number;
+    signal: NodeJS.Signals | null;
+    timedOut: boolean;
+    stdout: string;
+    stderr: string;
+}
+export type JsonValue = null | boolean | number | string | JsonValue[] | {
+    [key: string]: JsonValue;
+};
+export type JsonObject = Record<string, JsonValue | undefined>;
+export interface MockToolCall {
+    name: string;
+    args: Record<string, JsonValue>;
+}
+export interface MockToolCandidate {
+    name: string;
+    parameters: JsonObject;
+    args: Record<string, JsonValue>;
+}
+export interface MockScenarioContext {
+    model: string;
+    body: JsonObject;
+    repoRoot: string;
+}
+export interface MockScenarioHelpers {
+    hasToolResult: (body: JsonObject) => boolean;
+    isTitleGenerationRequest: (body: JsonObject) => boolean;
+    pickToolCall: (body: JsonObject) => MockToolCall | undefined;
+    getRequestText: (body: JsonObject) => string;
+}
+export type MockScenarioTurn = {
+    kind: 'message';
+    text: string;
+} | {
+    kind: 'tool';
+    tool: MockToolCall;
+};
+export interface MockLlmTraceEntry {
+    path: string;
+    model: string;
+    requestText: string;
+    inputTypes: string[];
+    requestedToolCount: number;
+    selectedTool: MockToolCall | undefined;
+    response: MockScenarioTurn;
+}
+export interface MockModelScenario {
+    id: string;
+    aliases?: string[];
+    title: string;
+    finalOutput: string;
+    resolveTurn?: (context: MockScenarioContext, helpers: MockScenarioHelpers) => MockScenarioTurn;
+}
+export interface MockLlmServerOptions {
+    scenarios?: MockModelScenario[];
+    debug?: boolean;
+}
+export interface MockLlmServerHandle {
+    port: number;
+    getTrace: () => MockLlmTraceEntry[];
+    close: () => Promise<void>;
+}
+export interface MockScenarioRule {
+    id: string;
+    when: (context: MockScenarioContext, helpers: MockScenarioHelpers) => boolean;
+    respond: MockScenarioTurn | ((context: MockScenarioContext, helpers: MockScenarioHelpers) => MockScenarioTurn);
+}
+export interface AdapterE2ECase {
+    id: string;
+    title: string;
+    adapter: AdapterE2ETarget;
+    prompt?: string;
+    model?: string;
+    allowedTransports?: AdapterTransport[];
+    extraArgs?: string[];
+    mockScenarios?: MockModelScenario[];
+    expectations?: AdapterE2ECaseExpectations;
+}
+export interface ResolvedAdapterE2ECase {
+    id: string;
+    title: string;
+    adapter: AdapterE2ETarget;
+    prompt: string;
+    model: string;
+    allowedTransports: AdapterTransport[];
+    args: (sessionId: string) => string[];
+    mockScenarios: MockModelScenario[];
+    expectations: AdapterE2ECaseExpectations;
+}

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

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -0,0 +1,13 @@
+import type { AdapterE2ETarget, VerifiedManagedArtifact } from './types';
+export declare const resolveLogPath: (ctxId: string, sessionId: string) => string;
+export declare const readHookLog: (input: {
+    ctxId: string;
+    sessionId: string;
+}) => Promise<{
+    logPath: string;
+    content: string;
+}>;
+export declare const collectManagedArtifacts: (input: {
+    adapter: AdapterE2ETarget;
+    sessionId: string;
+}) => Promise<VerifiedManagedArtifact[]>;

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

@@ -0,0 +1,65 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.collectManagedArtifacts = exports.readHookLog = exports.resolveLogPath = void 0;
+const promises_1 = require("node:fs/promises");
+const node_path_1 = __importDefault(require("node:path"));
+const runtime_1 = require("./runtime");
+const scenarios_1 = require("./scenarios");
+const resolveLogPath = (ctxId, sessionId) => (node_path_1.default.resolve(runtime_1.repoRoot, '.ai/logs', ctxId, `${sessionId}.log.md`));
+exports.resolveLogPath = resolveLogPath;
+const readHookLog = async (input) => {
+    const logPath = (0, exports.resolveLogPath)(input.ctxId, input.sessionId);
+    const exists = await (0, runtime_1.waitForPath)(logPath, 2_000);
+    if (!exists) {
+        throw new Error(`Smoke log not found: ${logPath}`);
+    }
+    const content = await (0, promises_1.readFile)(logPath, 'utf8');
+    if (!content.includes('"redacted": true')) {
+        throw new Error(`Expected sanitized hook log payload in ${logPath}`);
+    }
+    if (content.includes('hook-smoke-local')) {
+        throw new Error(`Log leaked mock api key in ${logPath}`);
+    }
+    return {
+        logPath,
+        content
+    };
+};
+exports.readHookLog = readHookLog;
+const resolveArtifactPath = (filePath, sessionId) => filePath.replace(':sessionId', sessionId);
+const collectManagedArtifacts = async (input) => {
+    const definitions = scenarios_1.MANAGED_ARTIFACTS[input.adapter];
+    const results = [];
+    for (const definition of definitions) {
+        let matchedCandidate;
+        for (const candidate of definition.candidates) {
+            const candidatePath = resolveArtifactPath(candidate.path, input.sessionId);
+            const exists = await (0, runtime_1.waitForPath)(candidatePath, 5_000);
+            if (!exists)
+                continue;
+            const content = await (0, promises_1.readFile)(candidatePath, 'utf8');
+            const missing = candidate.includes.find(needle => !content.includes(needle));
+            if (missing != null)
+                continue;
+            matchedCandidate = {
+                label: definition.label,
+                path: candidatePath,
+                includes: candidate.includes,
+                content
+            };
+            break;
+        }
+        if (matchedCandidate == null) {
+            const attemptedPaths = definition.candidates
+                .map(candidate => resolveArtifactPath(candidate.path, input.sessionId))
+                .join(', ');
+            throw new Error(`Managed artifact ${definition.label} not satisfied by any candidate: ${attemptedPaths}`);
+        }
+        results.push(matchedCandidate);
+    }
+    return results;
+};
+exports.collectManagedArtifacts = collectManagedArtifacts;

package/dist/scripts/cli.d.ts

@@ -0,0 +1,14 @@
+import { Command } from 'commander';
+import { runAdapterE2ESuite } from './adapter-e2e/harness';
+interface ScriptsCliDeps {
+    runAdapterSuite: typeof runAdapterE2ESuite;
+    runAdapterVitest: (input: {
+        selection: string | undefined;
+        updateSnapshots: boolean;
+        verbose: boolean;
+    }) => Promise<void>;
+    runPublishPlan: (args: string[]) => Promise<unknown>;
+}
+export declare const createScriptsCli: (deps?: ScriptsCliDeps) => Command;
+export declare const runScriptsCli: (argv?: string[], deps?: ScriptsCliDeps) => Promise<void>;
+export {};

package/dist/scripts/cli.js

@@ -0,0 +1,90 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runScriptsCli = exports.createScriptsCli = void 0;
+const commander_1 = require("commander");
+const node_process_1 = __importDefault(require("node:process"));
+const cases_1 = require("./__tests__/adapter-e2e/cases");
+const harness_1 = require("./adapter-e2e/harness");
+const runtime_1 = require("./adapter-e2e/runtime");
+const runVitestAdapterE2E = async (input) => {
+    const result = await (0, runtime_1.runProcess)({
+        command: 'pnpm',
+        args: [
+            'exec',
+            'vitest',
+            'run',
+            '--workspace',
+            'vitest.workspace.ts',
+            '--project',
+            'node',
+            'scripts/__tests__/adapter-e2e/adapter-e2e.spec.ts',
+            ...(input.updateSnapshots ? ['-u'] : [])
+        ],
+        env: {
+            ...node_process_1.default.env,
+            VF_RUN_ADAPTER_E2E: '1',
+            VF_ADAPTER_E2E_SELECTION: (0, cases_1.parseAdapterE2ESelection)(input.selection),
+            ...(input.verbose ? { VF_E2E_VERBOSE: '1' } : {})
+        },
+        passthroughStdIO: true
+    });
+    if (result.code !== 0) {
+        node_process_1.default.exitCode = result.code;
+    }
+};
+const defaultDeps = {
+    runAdapterSuite: harness_1.runAdapterE2ESuite,
+    runAdapterVitest: runVitestAdapterE2E,
+    runPublishPlan: async (args) => {
+        const { runPublishPlanCli } = await import('./publish-plan-core.mjs');
+        return runPublishPlanCli(args);
+    }
+};
+const createScriptsCli = (deps = defaultDeps) => {
+    const program = new commander_1.Command();
+    program
+        .name('vf-dev')
+        .description('Workspace maintenance commands');
+    const adapterE2ECommand = program
+        .command('adapter-e2e')
+        .description('Run adapter end-to-end verification flows');
+    adapterE2ECommand
+        .command('run [selection]')
+        .description('Run a real offline adapter E2E flow by adapter, case id, or all')
+        .option('--quiet', 'Do not stream child CLI output', false)
+        .option('--no-summary', 'Disable scenario summary output')
+        .action(async (target, options) => {
+        await deps.runAdapterSuite((0, cases_1.parseAdapterE2ESelection)(target), {
+            passthroughStdIO: !options.quiet,
+            printSummary: options.summary ?? true
+        });
+    });
+    adapterE2ECommand
+        .command('test [selection]')
+        .description('Run the Vitest adapter E2E suite by adapter, case id, or all')
+        .option('--verbose', 'Enable verbose child CLI output', false)
+        .option('-u, --update', 'Update Vitest file snapshots', false)
+        .action(async (selection, options) => {
+        await deps.runAdapterVitest({
+            selection: (0, cases_1.parseAdapterE2ESelection)(selection),
+            updateSnapshots: options.update ?? false,
+            verbose: options.verbose ?? false
+        });
+    });
+    program
+        .command('publish-plan [args...]')
+        .allowUnknownOption()
+        .description('Run the publish plan tool with passthrough arguments')
+        .action(async (args = []) => {
+        await deps.runPublishPlan(args);
+    });
+    return program;
+};
+exports.createScriptsCli = createScriptsCli;
+const runScriptsCli = async (argv = node_process_1.default.argv, deps = defaultDeps) => {
+    await (0, exports.createScriptsCli)(deps).parseAsync(argv);
+};
+exports.runScriptsCli = runScriptsCli;

package/dist/vitest.workspace.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("vitest/config.js", { with: { "resolution-mode": "import" } }).WorkspaceProjectConfiguration[];
+export default _default;