@vibe-forge/tsconfigs 0.7.2 → 0.9.0

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
+});

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,4 @@
+import { ensureClaudeNativeHooksInstalled } from './native-hooks';
+export const initClaudeCodeAdapter = async (ctx) => {
+    await ensureClaudeNativeHooksInstalled(ctx);
+};

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,11 @@
+import type { AdapterCtx, AdapterQueryOptions } from '@vibe-forge/types';
+interface PreparedClaudeExecution {
+    cliPath: string;
+    args: string[];
+    env: Record<string, string | null | undefined>;
+    cwd: string;
+    sessionId: string;
+    executionType: 'create' | 'resume';
+}
+export declare const prepareClaudeExecution: (ctx: AdapterCtx, options: AdapterQueryOptions) => Promise<PreparedClaudeExecution>;
+export {};