@vibe-forge/tsconfigs 0.7.2 → 0.8.0

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

@@ -0,0 +1,11 @@
+export interface AdapterBuiltinModel {
+    value: string;
+    title: string;
+    description: string;
+}
+/**
+ * Claude Code native model options.
+ * These models are supported directly by the `claude` CLI binary
+ * and do not require CCR routing.
+ */
+export declare const builtinModels: AdapterBuiltinModel[];

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

@@ -0,0 +1,37 @@
+/**
+ * Claude Code native model options.
+ * These models are supported directly by the `claude` CLI binary
+ * and do not require CCR routing.
+ */
+export const builtinModels = [
+    {
+        value: 'default',
+        title: 'default',
+        description: '推荐的模型设置，取决于你的账户类型'
+    },
+    {
+        value: 'sonnet',
+        title: 'sonnet',
+        description: '使用最新的 Sonnet 模型（当前为 Sonnet 4.6）用于日常编码任务'
+    },
+    {
+        value: 'opus',
+        title: 'opus',
+        description: '使用最新的 Opus 模型（当前为 Opus 4.6）用于复杂推理任务'
+    },
+    {
+        value: 'haiku',
+        title: 'haiku',
+        description: '使用快速高效的 Haiku 模型用于简单任务'
+    },
+    {
+        value: 'sonnet[1m]',
+        title: 'sonnet[1m]',
+        description: '使用 Sonnet 和 100 万 token 上下文窗口用于长会话'
+    },
+    {
+        value: 'opusplan',
+        title: 'opusplan',
+        description: '特殊模式，在计划模式中使用 Opus，然后在执行时切换到 Sonnet'
+    }
+];

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

@@ -0,0 +1,4 @@
+import type { AdapterMessageContent } from '@vibe-forge/types';
+import type { ClaudeCodeContent } from '../types';
+export declare const prefixToolName: (name: string) => string;
+export declare const mapAdapterContentToClaudeContent: (content: AdapterMessageContent[]) => ClaudeCodeContent[];

package/dist/packages/adapters/claude-code/src/protocol/content.js

@@ -0,0 +1,54 @@
+export const prefixToolName = (name) => (name.startsWith('adapter:claude-code:') ? name : `adapter:claude-code:${name}`);
+const parseDataUrl = (dataUrl) => {
+    if (!dataUrl.startsWith('data:'))
+        return null;
+    const commaIndex = dataUrl.indexOf(',');
+    if (commaIndex < 0)
+        return null;
+    const meta = dataUrl.slice('data:'.length, commaIndex);
+    const data = dataUrl.slice(commaIndex + 1);
+    const parts = meta.split(';').filter(p => p.trim() !== '');
+    const mediaType = parts[0] ?? '';
+    const isBase64 = parts.includes('base64');
+    if (!isBase64)
+        return null;
+    if (mediaType.trim() === '')
+        return null;
+    if (data.trim() === '')
+        return null;
+    return { mediaType, data };
+};
+export const mapAdapterContentToClaudeContent = (content) => content.map((item) => {
+    if (item.type === 'text') {
+        return { type: 'text', text: item.text };
+    }
+    if (item.type === 'tool_use') {
+        const name = item.name.startsWith('adapter:claude-code:')
+            ? item.name.replace('adapter:claude-code:', '')
+            : item.name;
+        return { type: 'tool_use', id: item.id, name, input: item.input };
+    }
+    if (item.type === 'tool_result') {
+        return {
+            type: 'tool_result',
+            tool_use_id: item.tool_use_id,
+            content: item.content,
+            is_error: item.is_error
+        };
+    }
+    if (item.type === 'image') {
+        const parsed = parseDataUrl(item.url);
+        if (parsed != null) {
+            return {
+                type: 'image',
+                source: {
+                    type: 'base64',
+                    media_type: item.mimeType ?? parsed.mediaType,
+                    data: parsed.data
+                }
+            };
+        }
+        return { type: 'text', text: `[Image] ${item.url}` };
+    }
+    return { type: 'text', text: '' };
+});

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

@@ -0,0 +1,3 @@
+import type { AdapterQueryOptions } from '@vibe-forge/types';
+import type { ClaudeCodeIncomingEvent } from '../types';
+export declare const handleIncomingEvent: (data: ClaudeCodeIncomingEvent, onEvent: AdapterQueryOptions["onEvent"]) => void;

package/dist/packages/adapters/claude-code/src/protocol/incoming.js

@@ -0,0 +1,131 @@
+import { prefixToolName } from './content';
+export const handleIncomingEvent = (data, onEvent) => {
+    const emitResultError = (params) => {
+        onEvent({
+            type: 'error',
+            data: {
+                message: params.message,
+                details: params.details,
+                fatal: true
+            }
+        });
+    };
+    if (data.type === 'system') {
+        if (data.subtype === 'init') {
+            onEvent({
+                type: 'init',
+                data: {
+                    uuid: data.uuid,
+                    model: data.model,
+                    version: data.claude_code_version,
+                    tools: (data.tools),
+                    slashCommands: (data.slash_commands),
+                    cwd: data.cwd,
+                    agents: (data.agents)
+                }
+            });
+        }
+    }
+    if (data.type === 'assistant' && data.message != null) {
+        const contentParts = data.message.content;
+        const textContent = contentParts
+            .filter((p) => p.type === 'text')
+            .map(p => p.text)
+            .join('');
+        const toolUsePart = contentParts.find((p) => p.type === 'tool_use');
+        const assistant = {
+            id: data.uuid,
+            role: 'assistant',
+            content: textContent,
+            createdAt: Date.now(),
+            model: data.message.model || data.model,
+            usage: data.message.usage
+        };
+        if (toolUsePart != null) {
+            const toolItem = {
+                type: 'tool_use',
+                id: toolUsePart.id,
+                name: prefixToolName(toolUsePart.name),
+                input: (toolUsePart.input ?? toolUsePart.args ?? {})
+            };
+            if (textContent !== '') {
+                assistant.content = [
+                    { type: 'text', text: textContent },
+                    toolItem
+                ];
+            }
+            else {
+                assistant.content = [toolItem];
+            }
+        }
+        onEvent({ type: 'message', data: assistant });
+    }
+    if (data.type === 'user' && data.message != null && Array.isArray(data.message.content)) {
+        const content = data.message.content;
+        const toolResultPart = content.find((p) => p.type === 'tool_result');
+        if (toolResultPart != null) {
+            const resultMessage = {
+                id: data.uuid,
+                role: 'assistant',
+                content: [{
+                        type: 'tool_result',
+                        tool_use_id: toolResultPart.tool_use_id,
+                        content: toolResultPart.content,
+                        is_error: toolResultPart.is_error ?? false
+                    }],
+                createdAt: Date.now()
+            };
+            onEvent({ type: 'message', data: resultMessage });
+        }
+    }
+    if (data.type === 'summary') {
+        onEvent({
+            type: 'summary',
+            data: {
+                summary: data.summary,
+                leafUuid: data.leafUuid
+            }
+        });
+    }
+    if (data.type === 'result') {
+        if (data.subtype === 'error_during_execution') {
+            const errors = Array.isArray(data.errors) ? data.errors.filter(error => error.trim() !== '') : [];
+            emitResultError({
+                message: errors[0] ?? 'Claude Code execution failed',
+                details: {
+                    errors,
+                    sessionId: data.session_id
+                }
+            });
+            return;
+        }
+        if (data.subtype !== 'success') {
+            return;
+        }
+        if (data.is_error) {
+            emitResultError({
+                message: data.result !== '' ? data.result : 'Claude Code execution failed',
+                details: {
+                    sessionId: data.session_id,
+                    durationMs: data.duration_ms,
+                    durationApiMs: data.duration_api_ms,
+                    numTurns: data.num_turns,
+                    totalCostUsd: data.total_cost_usd,
+                    usage: data.usage,
+                    permissionDenials: data.permission_denials
+                }
+            });
+        }
+        let messageData;
+        if (data.result != null && data.result !== '') {
+            messageData = {
+                id: data.uuid,
+                role: 'assistant',
+                content: data.result,
+                createdAt: Date.now(),
+                usage: data.usage
+            };
+        }
+        onEvent({ type: 'stop', data: messageData });
+    }
+};

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

@@ -0,0 +1,2 @@
+import type { AdapterCtx } from '@vibe-forge/types';
+export declare const initClaudeCodeAdapter: (ctx: AdapterCtx) => Promise<void>;

package/dist/packages/adapters/claude-code/src/runtime/init.js

@@ -0,0 +1,49 @@
+import { spawn } from 'node:child_process';
+import { existsSync } from 'node:fs';
+import { mkdir, writeFile } from 'node:fs/promises';
+import { dirname, resolve } from 'node:path';
+import process from 'node:process';
+import { omitAdapterCommonConfig } from '@vibe-forge/utils';
+import { generateDefaultCCRConfigJSON } from '../ccr/default-config';
+import { resolveAdapterCliPath } from '../ccr/paths';
+import { ensureClaudeNativeHooksInstalled } from './native-hooks';
+export const initClaudeCodeAdapter = async (ctx) => {
+    const { cwd, env, configs: [config, userConfig] } = ctx;
+    const adapterOptions = omitAdapterCommonConfig({
+        ...(config?.adapters?.['claude-code'] ?? {}),
+        ...(userConfig?.adapters?.['claude-code'] ?? {})
+    });
+    const configPath = resolve(cwd, '.ai/.mock/.claude-code-router/config.json');
+    await mkdir(dirname(configPath), { recursive: true });
+    await writeFile(configPath, generateDefaultCCRConfigJSON({
+        cwd,
+        config,
+        userConfig,
+        adapterOptions
+    }));
+    await ensureClaudeNativeHooksInstalled(ctx);
+    const homePath = resolve(cwd, '.ai/.mock');
+    const cliPath = resolveAdapterCliPath();
+    if (!existsSync(cliPath)) {
+        return;
+    }
+    await new Promise((resolvePromise, reject) => {
+        const proc = spawn(cliPath, ['restart'], {
+            env: {
+                ...process.env,
+                ...env,
+                HOME: homePath
+            },
+            cwd
+        });
+        proc.on('exit', (code) => {
+            if (code === 0) {
+                resolvePromise(null);
+            }
+            else {
+                reject(new Error(`ccr restart failed with code ${code}`));
+            }
+        });
+        proc.on('error', reject);
+    });
+};

package/dist/packages/adapters/claude-code/src/runtime/native-hooks.d.ts

@@ -0,0 +1,3 @@
+import type { AdapterCtx } from '@vibe-forge/types';
+export declare const CLAUDE_NATIVE_HOOK_EVENTS: readonly ["SessionStart", "UserPromptSubmit", "PreToolUse", "PostToolUse", "Notification", "Stop", "SubagentStop", "PreCompact"];
+export declare const ensureClaudeNativeHooksInstalled: (ctx: Pick<AdapterCtx, "cwd" | "env" | "logger" | "assets">) => Promise<boolean>;

package/dist/packages/adapters/claude-code/src/runtime/native-hooks.js

@@ -0,0 +1,72 @@
+import { resolve } from 'node:path';
+import { buildNodeScriptCommand, hasManagedHookPlugins, mergeManagedHookGroups, prepareManagedHookRuntime, readJsonFileOrDefault, resolveManagedHookScriptPath, writeJsonFile } from '@vibe-forge/hooks';
+export const CLAUDE_NATIVE_HOOK_EVENTS = [
+    'SessionStart',
+    'UserPromptSubmit',
+    'PreToolUse',
+    'PostToolUse',
+    'Notification',
+    'Stop',
+    'SubagentStop',
+    'PreCompact'
+];
+const isRecord = (value) => (value != null && typeof value === 'object' && !Array.isArray(value));
+const MANAGED_COMMAND_PATH = resolveManagedHookScriptPath('call-hook.js');
+const MANAGED_COMMAND_MARKERS = [
+    MANAGED_COMMAND_PATH,
+    'vf-call-hook',
+    'claude-hook.js',
+    'call-hook.js'
+];
+const isManagedGroup = (group) => (Array.isArray(group.hooks) &&
+    group.hooks.some(hook => MANAGED_COMMAND_MARKERS.some(marker => hook.command.includes(marker))));
+const createManagedGroup = (command, eventName) => ({
+    ...(eventName === 'PreToolUse' || eventName === 'PostToolUse'
+        ? { matcher: '.*' }
+        : {}),
+    hooks: [{
+            type: 'command',
+            command,
+            timeout: 600,
+            statusMessage: `running vibe-forge ${eventName} hook`
+        }]
+});
+export const ensureClaudeNativeHooksInstalled = async (ctx) => {
+    const { env, logger, assets } = ctx;
+    env.__VF_PROJECT_AI_CLAUDE_NATIVE_HOOKS_AVAILABLE__ = '0';
+    const enabled = hasManagedHookPlugins({ assets });
+    try {
+        const { mockHome, nodePath } = prepareManagedHookRuntime(ctx);
+        const settingsPath = resolve(mockHome, '.claude', 'settings.json');
+        const projectSettingsPath = resolve(ctx.cwd, '.claude', 'settings.json');
+        const existing = await readJsonFileOrDefault(settingsPath, {});
+        const projectSettings = await readJsonFileOrDefault(projectSettingsPath, {});
+        const projectSettingsHooks = isRecord(projectSettings) && isRecord(projectSettings.hooks)
+            ? projectSettings.hooks
+            : undefined;
+        const projectManagedEvents = new Set(CLAUDE_NATIVE_HOOK_EVENTS.filter((eventName) => {
+            const hooks = projectSettingsHooks?.[eventName];
+            return Array.isArray(hooks) && hooks.some(group => isManagedGroup(group));
+        }));
+        const command = buildNodeScriptCommand({
+            nodePath,
+            scriptPath: MANAGED_COMMAND_PATH
+        });
+        const merged = mergeManagedHookGroups({
+            existing,
+            eventNames: CLAUDE_NATIVE_HOOK_EVENTS,
+            enabled,
+            isManagedGroup,
+            createGroup: (eventName) => createManagedGroup(command, eventName),
+            shouldManageEvent: (eventName) => !projectManagedEvents.has(eventName)
+        });
+        await writeJsonFile(settingsPath, merged);
+        env.__VF_PROJECT_AI_CLAUDE_NATIVE_HOOKS_AVAILABLE__ = enabled ? '1' : '0';
+        return enabled;
+    }
+    catch (error) {
+        logger.warn('[claude hooks] failed to install native hook bridge', error);
+        env.__VF_PROJECT_AI_CLAUDE_NATIVE_HOOKS_AVAILABLE__ = '0';
+        return false;
+    }
+};

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

@@ -0,0 +1,14 @@
+import type { AdapterCtx, AdapterQueryOptions } from '@vibe-forge/types';
+export declare const prepareClaudeExecution: (ctx: AdapterCtx, options: AdapterQueryOptions) => Promise<{
+    cliPath: string;
+    args: string[];
+    env: {
+        __VF_VIBE_FORGE_CLAUDE_HOOKS_ACTIVE__?: string | undefined;
+        __VF_VIBE_FORGE_HOOK_BRIDGE_ADAPTER__?: string | undefined;
+        __VF_CLAUDE_HOOK_RUNTIME__?: import("@vibe-forge/types").TaskRuntime | undefined;
+        __VF_CLAUDE_TASK_SESSION_ID__?: string | undefined;
+    };
+    cwd: string;
+    sessionId: string;
+    executionType: string;
+}>;

package/dist/packages/adapters/claude-code/src/runtime/prepare.js

@@ -0,0 +1,145 @@
+import { NATIVE_HOOK_BRIDGE_ADAPTER_ENV } from '@vibe-forge/hooks';
+import { resolveAdapterCliPath } from '../ccr/paths';
+export const prepareClaudeExecution = async (ctx, options) => {
+    const { env, cwd, cache, configs: [config, userConfig] } = ctx;
+    const assetPlan = options.assetPlan;
+    const nativeHooksAvailable = env.__VF_PROJECT_AI_CLAUDE_NATIVE_HOOKS_AVAILABLE__ === '1';
+    const { description, sessionId, model, type, systemPrompt, appendSystemPrompt = true, permissionMode, mcpServers: inputMCPServersRule, tools: inputToolsRule } = options;
+    const resumeState = await cache.get('adapter.claude-code.resume-state');
+    const executionType = type === 'resume' && resumeState?.canResume === true ? 'resume' : 'create';
+    const settings = {
+        mcpServers: assetPlan?.mcpServers ?? {
+            ...config?.mcpServers,
+            ...userConfig?.mcpServers
+        },
+        permissions: {
+            allow: [
+                ...(config?.permissions?.allow ?? []),
+                ...(userConfig?.permissions?.allow ?? [])
+            ],
+            deny: [
+                ...(config?.permissions?.deny ?? []),
+                ...(userConfig?.permissions?.deny ?? [])
+            ],
+            ask: [
+                ...(config?.permissions?.ask ?? []),
+                ...(userConfig?.permissions?.ask ?? [])
+            ],
+            defaultMode: permissionMode ??
+                userConfig?.permissions?.defaultMode ??
+                config?.permissions?.defaultMode
+        },
+        defaultIncludeMcpServers: [
+            ...(config?.defaultIncludeMcpServers ?? []),
+            ...(userConfig?.defaultIncludeMcpServers ?? [])
+        ],
+        defaultExcludeMcpServers: [
+            ...(config?.defaultExcludeMcpServers ?? []),
+            ...(userConfig?.defaultExcludeMcpServers ?? [])
+        ],
+        plansDirectory: './.ai/works',
+        env: {
+            ...(config?.env ?? {}),
+            ...(userConfig?.env ?? {}),
+            ...(nativeHooksAvailable
+                ? {
+                    __VF_VIBE_FORGE_CLAUDE_HOOKS_ACTIVE__: '1',
+                    [NATIVE_HOOK_BRIDGE_ADAPTER_ENV]: 'claude-code',
+                    __VF_CLAUDE_HOOK_RUNTIME__: options.runtime,
+                    __VF_CLAUDE_TASK_SESSION_ID__: sessionId
+                }
+                : {})
+        },
+        companyAnnouncements: [
+            ...(config?.announcements ?? []),
+            ...(userConfig?.announcements ?? [])
+        ],
+        enabledPlugins: assetPlan?.native.enabledPlugins ?? {
+            ...(config?.enabledPlugins ?? {}),
+            ...(userConfig?.enabledPlugins ?? {})
+        },
+        extraKnownMarketplaces: assetPlan?.native.extraKnownMarketplaces ?? {
+            ...(config?.extraKnownMarketplaces ?? {}),
+            ...(userConfig?.extraKnownMarketplaces ?? {})
+        }
+    };
+    const { mcpServers, ...unresolvedSettings } = settings;
+    unresolvedSettings.permissions.allow = [
+        ...(unresolvedSettings.permissions.allow ?? []),
+        ...(inputToolsRule?.include ?? [])
+    ];
+    unresolvedSettings.permissions.deny = [
+        ...(unresolvedSettings.permissions.deny ?? []),
+        ...(inputToolsRule?.exclude ?? [])
+    ];
+    const includeMcpServers = inputMCPServersRule?.include ?? settings.defaultIncludeMcpServers;
+    const excludeMcpServers = inputMCPServersRule?.exclude ?? settings.defaultExcludeMcpServers;
+    if ((includeMcpServers?.length ?? 0) > 0) {
+        Object.keys(mcpServers).forEach((key) => {
+            if (!includeMcpServers?.includes(key)) {
+                delete mcpServers[key];
+            }
+        });
+    }
+    if ((excludeMcpServers?.length ?? 0) > 0) {
+        Object.keys(mcpServers).forEach((key) => {
+            if (excludeMcpServers?.includes(key)) {
+                delete mcpServers[key];
+            }
+        });
+    }
+    const { cachePath: mcpCachePath } = await cache.set('adapter.claude-code.mcp', { mcpServers });
+    const { cachePath: settingsCachePath } = await cache.set('adapter.claude-code.settings', settings);
+    // Routing: model with "," → CCR proxy; model without "," → native claude binary.
+    //   "serviceKey,modelName" → ccr code ... --model serviceKey,modelName
+    //   "opus" / undefined     → claude ... --model opus  (or omit --model)
+    const useCCR = typeof model === 'string' && model.includes(',');
+    let cliPath;
+    const prefixArgs = [];
+    if (useCCR) {
+        cliPath = resolveAdapterCliPath();
+        prefixArgs.push('code');
+    }
+    else {
+        cliPath = 'claude';
+    }
+    const args = [
+        ...prefixArgs,
+        ...(description
+            ? [JSON.stringify(`${(description?.trimStart().startsWith('-') ? '\0' : '')}${(description.replace(/`/g, "'"))}`)]
+            : []),
+        '--mcp-config',
+        mcpCachePath,
+        '--settings',
+        settingsCachePath
+    ].filter((a) => typeof a === 'string');
+    if (executionType === 'create') {
+        args.push('--session-id', sessionId);
+    }
+    else {
+        args.push('--resume', sessionId);
+    }
+    if (model != null && model !== '')
+        args.push('--model', model);
+    if (systemPrompt != null && systemPrompt !== '') {
+        args.push(appendSystemPrompt ? '--append-system-prompt' : '--system-prompt', systemPrompt.replace(/`/g, "'"));
+    }
+    return {
+        cliPath: cliPath,
+        args,
+        env: {
+            ...env,
+            ...(nativeHooksAvailable
+                ? {
+                    __VF_VIBE_FORGE_CLAUDE_HOOKS_ACTIVE__: '1',
+                    [NATIVE_HOOK_BRIDGE_ADAPTER_ENV]: 'claude-code',
+                    __VF_CLAUDE_HOOK_RUNTIME__: options.runtime,
+                    __VF_CLAUDE_TASK_SESSION_ID__: sessionId
+                }
+                : {})
+        },
+        cwd,
+        sessionId,
+        executionType
+    };
+};

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

@@ -0,0 +1,6 @@
+import type { AdapterCtx, AdapterEvent, AdapterQueryOptions } from '@vibe-forge/types';
+export declare const createClaudeSession: (ctx: AdapterCtx, options: AdapterQueryOptions) => Promise<{
+    kill: () => boolean;
+    emit: (event: AdapterEvent) => void;
+    pid: number | undefined;
+}>;