@vibe-forge/tsconfigs 0.7.1 → 0.8.0

package/dist/packages/adapters/claude-code/__tests__/session.spec.js

@@ -0,0 +1,147 @@
+import { PassThrough } from 'node:stream';
+import { spawn } from 'node:child_process';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { createClaudeSession } from '../src/runtime/session';
+const mocks = vi.hoisted(() => ({
+    prepareClaudeExecution: vi.fn()
+}));
+vi.mock('node:child_process', () => ({
+    spawn: vi.fn()
+}));
+vi.mock('../src/runtime/prepare', () => ({
+    prepareClaudeExecution: mocks.prepareClaudeExecution
+}));
+const spawnMock = vi.mocked(spawn);
+function makeCtx() {
+    return {
+        ctxId: 'ctx',
+        cwd: '/tmp',
+        env: {},
+        cache: {
+            set: vi.fn(async () => ({ cachePath: '/tmp/cache.json' })),
+            get: vi.fn(async () => undefined)
+        },
+        logger: {
+            info: vi.fn(),
+            warn: vi.fn(),
+            error: vi.fn(),
+            debug: vi.fn()
+        },
+        configs: [undefined, undefined]
+    };
+}
+function makeProc(options = {}) {
+    const stdout = new PassThrough();
+    const stderr = new PassThrough();
+    const handlers = new Map();
+    const proc = {
+        stdout,
+        stderr,
+        stdin: new PassThrough(),
+        pid: 1234,
+        on: vi.fn((event, handler) => {
+            handlers.set(event, handler);
+            return proc;
+        }),
+        kill: vi.fn(() => {
+            handlers.get('exit')?.(0);
+            return true;
+        })
+    };
+    queueMicrotask(() => {
+        for (const line of options.stdout ?? []) {
+            stdout.write(line);
+        }
+        for (const line of options.stderr ?? []) {
+            stderr.write(line);
+        }
+        if (options.error) {
+            handlers.get('error')?.(options.error);
+            return;
+        }
+        handlers.get('exit')?.(options.exitCode ?? 0);
+    });
+    return proc;
+}
+describe('claude-code session error events', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+        mocks.prepareClaudeExecution.mockResolvedValue({
+            cliPath: 'claude',
+            args: ['run'],
+            env: {},
+            cwd: '/tmp',
+            sessionId: 'sess-1',
+            executionType: 'create'
+        });
+    });
+    afterEach(() => {
+        vi.clearAllMocks();
+    });
+    it('emits error before exit for non-zero stream exits', async () => {
+        spawnMock.mockImplementation(() => makeProc({
+            stderr: ['stream failed'],
+            exitCode: 1
+        }));
+        const events = [];
+        await createClaudeSession(makeCtx(), {
+            type: 'create',
+            runtime: 'server',
+            mode: 'stream',
+            sessionId: 'sess-1',
+            onEvent: (event) => events.push(event)
+        });
+        await new Promise(resolve => setTimeout(resolve, 10));
+        expect(events).toEqual([
+            {
+                type: 'error',
+                data: {
+                    message: 'stream failed',
+                    details: { stderr: 'stream failed' },
+                    fatal: true
+                }
+            },
+            {
+                type: 'exit',
+                data: {
+                    exitCode: 1,
+                    stderr: 'stream failed'
+                }
+            }
+        ]);
+    });
+    it('does not emit a duplicate fatal error after error_during_execution is already surfaced', async () => {
+        spawnMock.mockImplementation(() => makeProc({
+            stdout: [
+                `${JSON.stringify({
+                    type: 'result',
+                    subtype: 'error_during_execution',
+                    uuid: 'evt-1',
+                    timestamp: new Date().toISOString(),
+                    sessionId: 'sess-1',
+                    cwd: '/tmp',
+                    session_id: 'sess-1',
+                    errors: ['tool failed']
+                })}\n`
+            ],
+            exitCode: 1
+        }));
+        const events = [];
+        await createClaudeSession(makeCtx(), {
+            type: 'create',
+            runtime: 'server',
+            mode: 'stream',
+            sessionId: 'sess-1',
+            onEvent: (event) => events.push(event)
+        });
+        await new Promise(resolve => setTimeout(resolve, 10));
+        expect(events.filter((event) => event.type === 'error')).toHaveLength(1);
+        expect(events.at(-1)).toEqual({
+            type: 'exit',
+            data: {
+                exitCode: 1,
+                stderr: ''
+            }
+        });
+    });
+});

package/dist/packages/adapters/claude-code/src/adapter-config.d.ts

@@ -0,0 +1,30 @@
+export {};
+declare module '@vibe-forge/types' {
+    interface Cache {
+        'adapter.claude-code.mcp': Record<string, unknown>;
+        'adapter.claude-code.settings': Record<string, unknown>;
+        'adapter.claude-code.resume-state': {
+            canResume: boolean;
+        };
+    }
+    interface AdapterMap {
+        'claude-code': {
+            ccrOptions?: {
+                LOG?: boolean;
+                PORT?: string;
+                HOST?: string;
+                API_TIMEOUT_MS?: number;
+            };
+            ccrTransformers?: {
+                logger?: boolean;
+            };
+            modelFallbacks?: {
+                default?: string[];
+                background?: string[];
+                think?: string[];
+                longContext?: string[];
+            };
+            apiTimeout?: number;
+        };
+    }
+}

package/dist/packages/adapters/claude-code/src/adapter-config.js

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

package/dist/packages/adapters/claude-code/src/ccr/default-config.d.ts

@@ -0,0 +1,7 @@
+import type { Config } from '@vibe-forge/types';
+export declare const generateDefaultCCRConfigJSON: (params: {
+    cwd: string;
+    config?: Config;
+    userConfig?: Config;
+    adapterOptions?: NonNullable<Config["adapters"]>["claude-code"];
+}) => string;

package/dist/packages/adapters/claude-code/src/ccr/default-config.js

@@ -0,0 +1,249 @@
+import { resolveTransformerPath } from './paths';
+const getServiceQueryParams = (service) => {
+    const extra = (service.extra ?? {});
+    return extra.claudeCodeRouter?.queryParams ?? extra.codex?.queryParams;
+};
+const buildProviderBaseUrl = (service) => {
+    const queryParams = getServiceQueryParams(service);
+    if (queryParams == null || Object.keys(queryParams).length === 0) {
+        return service.apiBaseUrl;
+    }
+    const url = new URL(service.apiBaseUrl);
+    for (const [key, value] of Object.entries(queryParams)) {
+        if (typeof value !== 'string' || value.trim() === '')
+            continue;
+        url.searchParams.set(key, value);
+    }
+    return url.toString();
+};
+const normalizePositiveInteger = (value) => (typeof value === 'number' && Number.isFinite(value) && value > 0
+    ? Math.floor(value)
+    : undefined);
+const isPlainObject = (value) => (value != null && typeof value === 'object' && !Array.isArray(value));
+const hasMaxtokenTransformer = (use) => use.some((entry) => {
+    if (entry === 'maxtoken')
+        return true;
+    return Array.isArray(entry) && entry[0] === 'maxtoken';
+});
+const buildProviderTransformer = (service) => {
+    const baseValue = service.extra?.claudeCodeRouterTransformer;
+    const maxOutputTokens = normalizePositiveInteger(service.maxOutputTokens);
+    if (maxOutputTokens == null)
+        return baseValue;
+    if (!isPlainObject(baseValue)) {
+        return {
+            use: [
+                ['maxtoken', { max_tokens: maxOutputTokens }]
+            ]
+        };
+    }
+    const use = Array.isArray(baseValue.use) ? [...baseValue.use] : [];
+    if (!hasMaxtokenTransformer(use)) {
+        use.push(['maxtoken', { max_tokens: maxOutputTokens }]);
+    }
+    return {
+        ...baseValue,
+        use
+    };
+};
+const normalizeServiceModel = (serviceKey, modelName, modelServices) => {
+    const service = modelServices[serviceKey];
+    if (!service)
+        return undefined;
+    const models = service.models ?? [];
+    const aliasEntries = Object.entries(service.modelsAlias ?? {});
+    const aliasFromModel = aliasEntries.find(([, aliases]) => aliases.includes(modelName))?.[0];
+    if (aliasFromModel)
+        return aliasFromModel;
+    if (models.includes(modelName))
+        return modelName;
+    const aliasByKey = aliasEntries.find(([alias]) => alias === modelName)?.[0];
+    return aliasByKey;
+};
+const getServicePriority = (modelServices, config, userConfig) => {
+    const ordered = [
+        userConfig?.defaultModelService,
+        config?.defaultModelService,
+        ...Object.keys(modelServices)
+    ];
+    const seen = new Set();
+    return ordered.filter((value) => {
+        if (!value || seen.has(value))
+            return false;
+        if (!modelServices[value])
+            return false;
+        seen.add(value);
+        return true;
+    });
+};
+const resolveModelCandidate = (candidate, params) => {
+    const { modelServices, config, userConfig, defaultService } = params;
+    if (candidate.includes(',')) {
+        const [serviceKey, modelName] = candidate.split(',').map(item => item.trim());
+        if (!serviceKey || !modelName)
+            return undefined;
+        const normalized = normalizeServiceModel(serviceKey, modelName, modelServices);
+        return normalized ? `${serviceKey},${normalized}` : undefined;
+    }
+    const servicePriority = [
+        defaultService,
+        ...getServicePriority(modelServices, config, userConfig)
+    ].filter((value, index, array) => array.indexOf(value) === index);
+    for (const serviceKey of servicePriority) {
+        const normalized = normalizeServiceModel(serviceKey, candidate, modelServices);
+        if (normalized)
+            return `${serviceKey},${normalized}`;
+    }
+    return undefined;
+};
+const resolveDefaultModel = (params) => {
+    const { config, userConfig, modelServices } = params;
+    const providers = Object.entries(modelServices).map(([name, configValue]) => ({
+        name,
+        api_base_url: buildProviderBaseUrl(configValue),
+        api_key: configValue.apiKey,
+        models: configValue.models,
+        transformer: buildProviderTransformer(configValue)
+    }));
+    const defaultProvider = providers[0];
+    if (!defaultProvider) {
+        throw new Error('No modelServices found in config');
+    }
+    const defaultModelServiceInput = userConfig?.defaultModelService ?? config?.defaultModelService;
+    const defaultModelServiceName = defaultModelServiceInput && modelServices[defaultModelServiceInput]
+        ? defaultModelServiceInput
+        : defaultProvider.name;
+    const defaultModelInput = userConfig?.defaultModel ?? config?.defaultModel;
+    const resolvedByInput = defaultModelInput
+        ? resolveModelCandidate(defaultModelInput, {
+            modelServices,
+            config,
+            userConfig,
+            defaultService: defaultModelServiceName
+        })
+        : undefined;
+    if (resolvedByInput) {
+        return {
+            defaultModel: resolvedByInput,
+            providers,
+            defaultService: defaultModelServiceName
+        };
+    }
+    const fallbackModelName = modelServices[defaultModelServiceName]?.models?.[0] ??
+        defaultProvider.models?.[0];
+    if (!fallbackModelName) {
+        throw new Error(`模型服务 ${defaultModelServiceName} 无可用模型`);
+    }
+    const normalizedFallback = normalizeServiceModel(defaultModelServiceName, fallbackModelName, modelServices);
+    if (!normalizedFallback) {
+        throw new Error(`模型服务 ${defaultModelServiceName} 无可用模型`);
+    }
+    return {
+        defaultModel: `${defaultModelServiceName},${normalizedFallback}`,
+        providers,
+        defaultService: defaultModelServiceName
+    };
+};
+const resolveRouterModel = (params) => {
+    const { fallback, defaultModel, defaultService, modelServices, config, userConfig } = params;
+    if (fallback && fallback.length > 0) {
+        for (const candidate of fallback) {
+            const resolved = resolveModelCandidate(candidate, {
+                modelServices,
+                config,
+                userConfig,
+                defaultService
+            });
+            if (resolved)
+                return resolved;
+        }
+    }
+    return defaultModel;
+};
+const resolveCompatibleApiTimeoutMs = (params) => {
+    const { defaultService, modelServices, adapterOptions } = params;
+    const explicitCcrTimeout = normalizePositiveInteger(adapterOptions?.ccrOptions?.API_TIMEOUT_MS);
+    if (explicitCcrTimeout != null)
+        return explicitCcrTimeout;
+    const adapterTimeout = normalizePositiveInteger(adapterOptions?.apiTimeout);
+    if (adapterTimeout != null)
+        return adapterTimeout;
+    const timeoutByService = Object.fromEntries(Object.entries(modelServices)
+        .map(([serviceKey, service]) => [serviceKey, normalizePositiveInteger(service.timeoutMs)])
+        .filter((entry) => entry[1] != null));
+    const uniqueTimeouts = Array.from(new Set(Object.values(timeoutByService)));
+    if (uniqueTimeouts.length === 0)
+        return undefined;
+    if (uniqueTimeouts.length === 1)
+        return uniqueTimeouts[0];
+    return timeoutByService[defaultService] ?? uniqueTimeouts[0];
+};
+export const generateDefaultCCRConfigJSON = (params) => {
+    const { config, userConfig, adapterOptions } = params;
+    const modelServices = {
+        ...(config?.modelServices ?? {}),
+        ...(userConfig?.modelServices ?? {})
+    };
+    const { defaultModel, providers, defaultService } = resolveDefaultModel({
+        config,
+        userConfig,
+        modelServices
+    });
+    const loggerEnabled = adapterOptions?.ccrTransformers?.logger ?? true;
+    const apiTimeoutMs = resolveCompatibleApiTimeoutMs({
+        defaultService,
+        modelServices,
+        adapterOptions
+    });
+    const transformers = [
+        {
+            path: resolveTransformerPath('gemini-open-router-polyfill.js')
+        },
+        {
+            path: resolveTransformerPath('openai-polyfill.js')
+        },
+        ...(loggerEnabled
+            ? [{ path: resolveTransformerPath('logger.js') }]
+            : [])
+    ];
+    return JSON.stringify({
+        ...(adapterOptions?.ccrOptions ?? {}),
+        ...(apiTimeoutMs != null ? { API_TIMEOUT_MS: apiTimeoutMs } : {}),
+        transformers,
+        Providers: providers,
+        Router: {
+            default: resolveRouterModel({
+                fallback: adapterOptions?.modelFallbacks?.default,
+                defaultModel,
+                defaultService,
+                modelServices,
+                config,
+                userConfig
+            }),
+            background: resolveRouterModel({
+                fallback: adapterOptions?.modelFallbacks?.background,
+                defaultModel,
+                defaultService,
+                modelServices,
+                config,
+                userConfig
+            }),
+            think: resolveRouterModel({
+                fallback: adapterOptions?.modelFallbacks?.think,
+                defaultModel,
+                defaultService,
+                modelServices,
+                config,
+                userConfig
+            }),
+            longContext: resolveRouterModel({
+                fallback: adapterOptions?.modelFallbacks?.longContext,
+                defaultModel,
+                defaultService,
+                modelServices,
+                config,
+                userConfig
+            })
+        }
+    }, null, 2);
+};

package/dist/packages/adapters/claude-code/src/ccr/paths.d.ts

@@ -0,0 +1,7 @@
+export declare const toRealPath: (targetPath: string) => string;
+/**
+ * Resolve the CCR (claude-code-router) binary path.
+ * Resolved via `require.resolve` from the adapter package's dependencies.
+ */
+export declare const resolveAdapterCliPath: () => string;
+export declare const resolveTransformerPath: (relativePath: string) => string;

package/dist/packages/adapters/claude-code/src/ccr/paths.js

@@ -0,0 +1,29 @@
+import { existsSync, realpathSync } from 'node:fs';
+import { createRequire } from 'node:module';
+import { dirname, resolve } from 'node:path';
+const require = createRequire(import.meta.url ?? __filename);
+const adapterPackageDir = dirname(require.resolve('@vibe-forge/adapter-claude-code/package.json'));
+export const toRealPath = (targetPath) => {
+    try {
+        return realpathSync(targetPath);
+    }
+    catch {
+        return targetPath;
+    }
+};
+/**
+ * Resolve the CCR (claude-code-router) binary path.
+ * Resolved via `require.resolve` from the adapter package's dependencies.
+ */
+export const resolveAdapterCliPath = () => {
+    return toRealPath(resolve(adapterPackageDir, 'node_modules/.bin/ccr'));
+};
+export const resolveTransformerPath = (relativePath) => {
+    const distPath = resolve(adapterPackageDir, 'dist/ccr-transformers', relativePath);
+    if (existsSync(distPath))
+        return distPath;
+    const srcPath = resolve(adapterPackageDir, 'src/ccr-transformers', relativePath);
+    if (existsSync(srcPath))
+        return srcPath;
+    return resolve(adapterPackageDir, 'ccr-transformers', relativePath);
+};

package/dist/packages/adapters/claude-code/src/hook-bridge.d.ts

@@ -0,0 +1,114 @@
+import type { HookInput, HookInputs } from '@vibe-forge/hooks';
+export declare const isClaudeNativeHookEnv: () => boolean;
+export declare const mapClaudeHookInputToVibeForge: (input: HookInput) => {
+    sessionId: string;
+    adapter: string;
+    runtime: import("@vibe-forge/types").TaskRuntime | undefined;
+    hookSource: "native";
+    canBlock: boolean;
+    cwd: string;
+    hookEventName: keyof HookInputs;
+    transcriptPath?: string | null;
+    turnId?: string;
+    toolResponse?: unknown;
+    isError?: boolean;
+    toolCallId?: string;
+    toolName: string;
+    toolInput?: unknown;
+} | {
+    sessionId: string;
+    adapter: string;
+    runtime: import("@vibe-forge/types").TaskRuntime | undefined;
+    hookSource: "native";
+    canBlock: boolean;
+    cwd: string;
+    hookEventName: keyof HookInputs;
+    transcriptPath?: string | null;
+    turnId?: string;
+    prompt: string;
+} | {
+    sessionId: string;
+    adapter: string;
+    runtime: import("@vibe-forge/types").TaskRuntime | undefined;
+    hookSource: "native";
+    canBlock: boolean;
+    cwd: string;
+    hookEventName: keyof HookInputs;
+    transcriptPath?: string | null;
+    turnId?: string;
+    stopHookActive?: boolean;
+    lastAssistantMessage?: string;
+} | {
+    sessionId: string;
+    adapter: string;
+    runtime: import("@vibe-forge/types").TaskRuntime | undefined;
+    hookSource: "native";
+    canBlock: boolean;
+    cwd: string;
+    hookEventName: keyof HookInputs;
+    transcriptPath?: string | null;
+    turnId?: string;
+    source?: "startup" | "resume";
+    model?: string;
+} | {
+    sessionId: string;
+    adapter: string;
+    runtime: import("@vibe-forge/types").TaskRuntime | undefined;
+    hookSource: "native";
+    canBlock: boolean;
+    cwd: string;
+    hookEventName: keyof HookInputs;
+    transcriptPath?: string | null;
+    turnId?: string;
+    reason: string;
+    exitCode?: number;
+    stderr?: string;
+    lastAssistantMessage?: string;
+} | {
+    sessionId: string;
+    adapter: string;
+    runtime: import("@vibe-forge/types").TaskRuntime | undefined;
+    hookSource: "native";
+    canBlock: boolean;
+    cwd: string;
+    hookEventName: keyof HookInputs;
+    transcriptPath?: string | null;
+    turnId?: string;
+    tasks: Array<{
+        description: string;
+        type: "default" | "spec" | "entity";
+        name?: string;
+        adapter?: string;
+        background?: boolean;
+    }>;
+} | {
+    sessionId: string;
+    adapter: string;
+    runtime: import("@vibe-forge/types").TaskRuntime | undefined;
+    hookSource: "native";
+    canBlock: boolean;
+    cwd: string;
+    hookEventName: keyof HookInputs;
+    transcriptPath?: string | null;
+    turnId?: string;
+    type?: "spec" | "entity";
+    name?: string;
+    data?: unknown;
+} | {
+    sessionId: string;
+    adapter: string;
+    runtime: import("@vibe-forge/types").TaskRuntime | undefined;
+    hookSource: "native";
+    canBlock: boolean;
+    cwd: string;
+    hookEventName: keyof HookInputs;
+    transcriptPath?: string | null;
+    turnId?: string;
+    exitCode?: number;
+    stderr?: string;
+    options: unknown;
+    adapterOptions: unknown;
+} | undefined;
+export declare const runClaudeHookBridge: () => Promise<void>;
+export declare const isNativeHookEnv: () => boolean;
+export declare const runHookBridge: () => Promise<void>;

package/dist/packages/adapters/claude-code/src/hook-bridge.js

@@ -0,0 +1,55 @@
+import process from 'node:process';
+import { executeHookInput, readHookInput } from '@vibe-forge/hooks';
+const runtime = process.env.__VF_CLAUDE_HOOK_RUNTIME__;
+const taskSessionId = process.env.__VF_CLAUDE_TASK_SESSION_ID__?.trim();
+const SUPPORTED_EVENTS = new Set([
+    'SessionStart',
+    'UserPromptSubmit',
+    'PreToolUse',
+    'PostToolUse',
+    'Notification',
+    'Stop',
+    'SubagentStop',
+    'PreCompact'
+]);
+const BLOCKABLE_EVENTS = new Set([
+    'SessionStart',
+    'UserPromptSubmit',
+    'PreToolUse',
+    'PostToolUse',
+    'PreCompact'
+]);
+export const isClaudeNativeHookEnv = () => (process.env.__VF_VIBE_FORGE_CLAUDE_HOOKS_ACTIVE__ === '1');
+const canBlock = (eventName) => BLOCKABLE_EVENTS.has(eventName);
+export const mapClaudeHookInputToVibeForge = (input) => {
+    if (!SUPPORTED_EVENTS.has(input.hookEventName))
+        return undefined;
+    return {
+        ...input,
+        sessionId: taskSessionId || input.sessionId,
+        adapter: 'claude-code',
+        runtime: input.runtime ?? runtime,
+        hookSource: 'native',
+        canBlock: input.canBlock ?? canBlock(input.hookEventName)
+    };
+};
+export const runClaudeHookBridge = async () => {
+    try {
+        const input = await readHookInput();
+        const hookInput = mapClaudeHookInputToVibeForge(input);
+        if (hookInput == null) {
+            process.stdout.write(`${JSON.stringify({ continue: true })}\n`);
+            return;
+        }
+        const result = await executeHookInput(hookInput);
+        process.stdout.write(`${JSON.stringify(result)}\n`);
+    }
+    catch (error) {
+        process.stdout.write(`${JSON.stringify({
+            continue: true,
+            systemMessage: `vibe-forge claude hook bridge error: ${String(error)}`
+        })}\n`);
+    }
+};
+export const isNativeHookEnv = isClaudeNativeHookEnv;
+export const runHookBridge = runClaudeHookBridge;

package/dist/packages/adapters/claude-code/src/icon.d.ts

@@ -0,0 +1,2 @@
+export declare const adapterIcon: string;
+export declare const adapterDisplayName = "Claude Code";

package/dist/packages/adapters/claude-code/src/icon.js

@@ -0,0 +1,20 @@
+const CLAUDE_CODE_ICON_SVG = `
+<svg width="64" height="64" viewBox="0 0 64 64" fill="none" xmlns="http://www.w3.org/2000/svg">
+  <g fill="#D97957">
+    <rect x="29" y="2" width="6" height="20" rx="3"/>
+    <rect x="29" y="42" width="6" height="20" rx="3"/>
+    <rect x="42" y="29" width="20" height="6" rx="3"/>
+    <rect x="2" y="29" width="20" height="6" rx="3"/>
+    <rect x="29" y="2" width="6" height="20" rx="3" transform="rotate(30 32 32)"/>
+    <rect x="29" y="2" width="6" height="20" rx="3" transform="rotate(60 32 32)"/>
+    <rect x="29" y="2" width="6" height="20" rx="3" transform="rotate(120 32 32)"/>
+    <rect x="29" y="2" width="6" height="20" rx="3" transform="rotate(150 32 32)"/>
+    <rect x="29" y="2" width="6" height="20" rx="3" transform="rotate(-30 32 32)"/>
+    <rect x="29" y="2" width="6" height="20" rx="3" transform="rotate(-60 32 32)"/>
+    <rect x="29" y="2" width="6" height="20" rx="3" transform="rotate(-120 32 32)"/>
+    <rect x="29" y="2" width="6" height="20" rx="3" transform="rotate(-150 32 32)"/>
+    <circle cx="32" cy="32" r="11"/>
+  </g>
+</svg>`.trim();
+export const adapterIcon = `data:image/svg+xml;utf8,${encodeURIComponent(CLAUDE_CODE_ICON_SVG)}`;
+export const adapterDisplayName = 'Claude Code';

package/dist/packages/adapters/claude-code/src/index.d.ts

@@ -0,0 +1,3 @@
+import './adapter-config';
+declare const _default: import("@vibe-forge/types").Adapter;
+export default _default;

package/dist/packages/adapters/claude-code/src/index.js

@@ -0,0 +1,8 @@
+import './adapter-config';
+import { defineAdapter } from '@vibe-forge/types';
+import { initClaudeCodeAdapter } from './runtime/init';
+import { createClaudeSession } from './runtime/session';
+export default defineAdapter({
+    init: initClaudeCodeAdapter,
+    query: createClaudeSession
+});