@vibe-lang/runtime 0.2.5

package/src/runtime/ai-logger.ts

@@ -0,0 +1,255 @@
+// AI Interaction Logging Utilities
+// Formats AI interactions for debugging and analysis
+//
+// This logger uses the stored context from AIInteraction which is the
+// SINGLE SOURCE OF TRUTH for what was sent to the model.
+// The context is captured in ai-provider.ts using buildAIContext().
+
+import { existsSync, mkdirSync, readdirSync, unlinkSync, writeFileSync } from 'fs';
+import { join } from 'path';
+import type { RuntimeState, AIInteraction, AILogMessage } from './types';
+
+const LOG_DIR = '.ai-logs';
+const MAX_LOGS = 20;
+
+/**
+ * Format a single message for display.
+ */
+function formatMessage(msg: AILogMessage): string {
+  const lines: string[] = [];
+
+  lines.push(`**[${msg.role}]**`);
+
+  // Content
+  if (msg.content) {
+    lines.push(msg.content);
+  }
+
+  // Tool calls (for assistant messages)
+  if (msg.toolCalls && msg.toolCalls.length > 0) {
+    lines.push('');
+    lines.push('*Tool calls:*');
+    for (const call of msg.toolCalls) {
+      lines.push(`- \`${call.toolName}(${JSON.stringify(call.args)})\``);
+    }
+  }
+
+  // Tool results (for user messages)
+  if (msg.toolResults && msg.toolResults.length > 0) {
+    lines.push('');
+    lines.push('*Tool results:*');
+    for (const result of msg.toolResults) {
+      if (result.error) {
+        lines.push(`- Error: ${result.error}`);
+      } else {
+        const resultStr = typeof result.result === 'string'
+          ? result.result
+          : JSON.stringify(result.result, null, 2);
+        lines.push(`- ${resultStr}`);
+      }
+    }
+  }
+
+  lines.push('');
+  return lines.join('\n');
+}
+
+/**
+ * Format tool calls that occurred during the interaction.
+ */
+function formatToolCalls(toolCalls: AIInteraction['interactionToolCalls']): string {
+  if (!toolCalls || toolCalls.length === 0) {
+    return '';
+  }
+
+  const lines: string[] = [];
+  lines.push('### Tool Calls During Interaction');
+  lines.push('');
+
+  for (const call of toolCalls) {
+    lines.push(`- \`${call.toolName}(${JSON.stringify(call.args)})\``);
+    if (call.error) {
+      lines.push(`  → Error: ${call.error}`);
+    } else if (call.result !== undefined) {
+      const resultStr = typeof call.result === 'string'
+        ? call.result
+        : JSON.stringify(call.result, null, 2);
+      lines.push(`  → ${resultStr}`);
+    }
+  }
+
+  lines.push('');
+  return lines.join('\n');
+}
+
+/**
+ * Format a single AI interaction as markdown.
+ * Uses the stored context which is the single source of truth.
+ */
+function formatInteraction(interaction: AIInteraction, index: number): string {
+  const lines: string[] = [];
+
+  // Header
+  lines.push(`## Interaction ${index + 1}`);
+  lines.push(`**Type:** ${interaction.type} | **Model:** ${interaction.model} | **Target:** ${interaction.targetType ?? 'text'}`);
+  lines.push('');
+
+  // Messages sent to model (from stored context - single source of truth)
+  // Note: The context is included in the user messages, so we don't need a separate section
+  lines.push('### Messages Sent to Model');
+  lines.push('');
+
+  for (const msg of interaction.messages) {
+    lines.push(formatMessage(msg));
+  }
+
+  // Tool calls that occurred during this interaction
+  if (interaction.interactionToolCalls && interaction.interactionToolCalls.length > 0) {
+    lines.push(formatToolCalls(interaction.interactionToolCalls));
+  }
+
+  // Response
+  lines.push('### Response');
+  lines.push('```');
+  if (typeof interaction.response === 'string') {
+    lines.push(interaction.response);
+  } else {
+    lines.push(JSON.stringify(interaction.response, null, 2));
+  }
+  lines.push('```');
+
+  // Metadata
+  if (interaction.usage || interaction.durationMs) {
+    lines.push('');
+
+    // Token usage
+    if (interaction.usage) {
+      const { inputTokens, outputTokens, cachedInputTokens, cacheCreationTokens, thinkingTokens } = interaction.usage;
+      let tokenStr = `**Tokens:** ${inputTokens} in`;
+      if (cachedInputTokens) {
+        tokenStr += ` (${cachedInputTokens} cached)`;
+      }
+      if (cacheCreationTokens) {
+        tokenStr += ` (${cacheCreationTokens} cache write)`;
+      }
+      tokenStr += ` / ${outputTokens} out`;
+      if (thinkingTokens) {
+        tokenStr += ` (${thinkingTokens} thinking)`;
+      }
+      lines.push(tokenStr);
+    }
+
+    // Duration
+    if (interaction.durationMs) {
+      lines.push(`**Duration:** ${interaction.durationMs}ms`);
+    }
+  }
+
+  return lines.join('\n');
+}
+
+/**
+ * Format all AI interactions as markdown.
+ */
+export function formatAIInteractions(interactions: AIInteraction[]): string {
+  if (interactions.length === 0) {
+    return 'No AI interactions recorded.';
+  }
+
+  // Collect unique models used
+  const modelsUsed = new Map<string, { name: string; provider: string; url?: string; thinkingLevel?: string }>();
+  for (const interaction of interactions) {
+    if (interaction.modelDetails && !modelsUsed.has(interaction.model)) {
+      modelsUsed.set(interaction.model, interaction.modelDetails);
+    }
+  }
+
+  // Build header with model info
+  const headerLines = [
+    '# AI Interaction Log',
+    '',
+    `Total interactions: ${interactions.length}`,
+  ];
+
+  if (modelsUsed.size > 0) {
+    headerLines.push('');
+    headerLines.push('## Models Used');
+    for (const [varName, details] of modelsUsed) {
+      let modelLine = `- **${varName}**: \`${details.name}\` via ${details.provider}`;
+      if (details.url) {
+        modelLine += ` @ ${details.url}`;
+      }
+      if (details.thinkingLevel) {
+        modelLine += ` (thinking: ${details.thinkingLevel})`;
+      }
+      headerLines.push(modelLine);
+    }
+  }
+
+  headerLines.push('');
+  headerLines.push('---');
+  headerLines.push('');
+
+  const header = headerLines.join('\n');
+  const formatted = interactions.map((interaction, i) => formatInteraction(interaction, i));
+
+  return header + formatted.join('\n\n---\n\n');
+}
+
+/**
+ * Dump AI interactions to console in a readable format.
+ */
+export function dumpAIInteractions(state: RuntimeState): void {
+  console.log('\n' + '='.repeat(60));
+  console.log('AI INTERACTION LOG');
+  console.log('='.repeat(60) + '\n');
+  console.log(formatAIInteractions(state.aiInteractions));
+  console.log('\n' + '='.repeat(60) + '\n');
+}
+
+/**
+ * Save AI interactions to a file in the log directory.
+ * Automatically rotates logs to keep only the last MAX_LOGS files.
+ */
+export function saveAIInteractions(state: RuntimeState, projectRoot?: string): string | null {
+  if (state.aiInteractions.length === 0) {
+    return null;
+  }
+
+  const logDir = projectRoot ? join(projectRoot, LOG_DIR) : LOG_DIR;
+
+  // Ensure log directory exists
+  if (!existsSync(logDir)) {
+    mkdirSync(logDir, { recursive: true });
+  }
+
+  // Generate filename with timestamp
+  const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+  const filename = `ai-log-${timestamp}.md`;
+  const filepath = join(logDir, filename);
+
+  // Write the log
+  const content = formatAIInteractions(state.aiInteractions);
+  writeFileSync(filepath, content, 'utf-8');
+
+  // Rotate logs - keep only the last MAX_LOGS
+  rotateLogFiles(logDir);
+
+  return filepath;
+}
+
+/**
+ * Remove old log files to keep only the last MAX_LOGS.
+ */
+function rotateLogFiles(logDir: string): void {
+  const files = readdirSync(logDir)
+    .filter(f => f.startsWith('ai-log-') && f.endsWith('.md'))
+    .sort()
+    .reverse(); // Newest first (ISO timestamp sorts correctly)
+
+  // Remove files beyond MAX_LOGS
+  const toDelete = files.slice(MAX_LOGS);
+  for (const file of toDelete) {
+    unlinkSync(join(logDir, file));
+  }
+}

package/src/runtime/ai-provider.ts

@@ -0,0 +1,347 @@
+// Real AI Provider Implementation
+// Uses the AI module to make actual API calls
+
+import type { AIProvider, AIExecutionResult } from './index';
+import type { RuntimeState, AILogMessage, PromptToolCall } from './types';
+import type { VibeModelValue, TargetType, AIRequest, ModelConfig, AIProviderType } from './ai';
+import type { VibeToolValue, ToolSchema } from './tools/types';
+import { detectProvider, getProviderExecutor, buildAIRequest } from './ai';
+import { withRetry } from './ai/retry';
+import { executeWithTools, type ToolRoundResult } from './ai/tool-loop';
+import { buildGlobalContext, formatContextForAI } from './context';
+import { buildAIContext } from './ai/context';
+import { buildVibeMessages, type VibeScopeParam } from './ai/formatters';
+import {
+  getReturnTools,
+  shouldUseReturnTool,
+  isReturnToolCall,
+  buildReturnInstruction,
+  collectAndValidateFieldResults,
+  isFieldReturnResult,
+  RETURN_FIELD_TOOL,
+} from './ai/return-tools';
+import type { ExpectedField } from './types';
+
+/**
+ * Get model value from runtime state by model name.
+ */
+function getModelValue(state: RuntimeState, modelName: string): VibeModelValue | null {
+  // Search through all frames for the model
+  for (let i = state.callStack.length - 1; i >= 0; i--) {
+    const frame = state.callStack[i];
+    const variable = frame.locals[modelName];
+    if (variable?.value && isModelValue(variable.value)) {
+      return variable.value;
+    }
+  }
+  return null;
+}
+
+/**
+ * Type guard for model values.
+ */
+function isModelValue(value: unknown): value is VibeModelValue {
+  return (
+    typeof value === 'object' &&
+    value !== null &&
+    '__vibeModel' in value &&
+    (value as VibeModelValue).__vibeModel === true
+  );
+}
+
+/**
+ * Get target type from the pending variable declaration context.
+ * Returns null if not in a variable declaration or no type annotation.
+ */
+function getTargetType(state: RuntimeState): TargetType {
+  // Look at the next instruction to see if we're assigning to a typed variable
+  const nextInstruction = state.instructionStack[0];
+  if (nextInstruction?.op === 'declare_var' && nextInstruction.type) {
+    const type = nextInstruction.type;
+    // Only return types that the AI module understands
+    if (['text', 'json', 'boolean', 'number'].includes(type) || type.endsWith('[]')) {
+      return type as TargetType;
+    }
+  }
+  return null;
+}
+
+/**
+ * Build model config from runtime model value.
+ */
+function buildModelConfig(modelValue: VibeModelValue): ModelConfig {
+  if (!modelValue.name) {
+    throw new Error('Model name is required');
+  }
+  if (!modelValue.apiKey) {
+    throw new Error('API key is required');
+  }
+
+  const provider: AIProviderType =
+    (modelValue.provider as AIProviderType) ?? detectProvider(modelValue.url);
+
+  return {
+    name: modelValue.name,
+    apiKey: modelValue.apiKey,
+    url: modelValue.url,
+    provider,
+    maxRetriesOnError: modelValue.maxRetriesOnError ?? undefined,
+  };
+}
+
+/**
+ * Create a real AI provider that uses actual API calls.
+ * The provider needs access to runtime state to get model configs.
+ */
+export function createRealAIProvider(getState: () => RuntimeState): AIProvider {
+  return {
+    async execute(prompt: string): Promise<AIExecutionResult> {
+      const state = getState();
+
+      // Get model name from pendingAI or pendingCompress
+      let modelName: string;
+      let aiType: 'do' | 'vibe' | 'compress';
+      if (state.pendingAI) {
+        modelName = state.pendingAI.model;
+        aiType = state.pendingAI.type;
+      } else if (state.pendingCompress) {
+        modelName = state.pendingCompress.model;
+        aiType = 'compress';
+      } else {
+        throw new Error('No pending AI or compress request');
+      }
+      const modelValue = getModelValue(state, modelName);
+      if (!modelValue) {
+        throw new Error(`Model '${modelName}' not found in scope`);
+      }
+
+      // Determine target type from pending variable declaration
+      const targetType = getTargetType(state);
+
+      // Build model config
+      const model = buildModelConfig(modelValue);
+
+      // Get tools from model (empty array if no tools specified)
+      const modelTools: VibeToolValue[] = (modelValue.tools as VibeToolValue[]) ?? [];
+
+      // Always include return tools (keeps tool list consistent for caching)
+      const returnTools = getReturnTools();
+      const allTools = [...returnTools, ...modelTools];
+      const toolSchemas: ToolSchema[] = allTools.map((t) => t.schema);
+
+      // Build expected fields for return validation
+      // Priority: 1) pendingDestructuring (multi-value), 2) targetType (single-value)
+      let expectedFields: ExpectedField[] | null = null;
+      if (state.pendingDestructuring) {
+        // Multi-value destructuring: const {name: text, age: number} = do "..."
+        expectedFields = state.pendingDestructuring.map((f) => ({ name: f.name, type: f.type }));
+      } else if (shouldUseReturnTool(targetType)) {
+        // Single-value typed return: const x: number = do "..."
+        expectedFields = [{ name: 'value', type: targetType! }];
+      }
+
+      // Determine if this request should use tool-based return
+      const useToolReturn = expectedFields !== null && expectedFields.length > 0;
+      const returnToolName = useToolReturn ? RETURN_FIELD_TOOL : null;
+
+      // Append return instruction to prompt if we have expected fields
+      const finalPrompt = expectedFields
+        ? prompt + buildReturnInstruction(expectedFields)
+        : prompt;
+
+      // Build unified AI context (single source of truth)
+      // Use finalPrompt so the log shows what was actually sent
+      const aiContext = buildAIContext(
+        state,
+        model,
+        finalPrompt,
+        // For tool-based returns, pass null to disable structured output
+        useToolReturn ? null : targetType,
+        toolSchemas.length > 0 ? toolSchemas : undefined
+      );
+
+      // Build context from global context for the request
+      const context = buildGlobalContext(state);
+      const formattedContext = formatContextForAI(context);
+
+      // Build the request with tools
+      // For compress, treat as single-round 'do' type
+      const requestType = aiType === 'compress' ? 'do' : aiType;
+
+      const request: AIRequest = {
+        ...buildAIRequest(
+          model,
+          finalPrompt,
+          formattedContext.text,
+          requestType,
+          // For tool-based returns, pass null to disable structured output
+          useToolReturn ? null : targetType
+        ),
+        tools: toolSchemas.length > 0 ? toolSchemas : undefined,
+      };
+
+      // Get provider executor (provider is always defined after buildModelConfig)
+      const execute = getProviderExecutor(model.provider!);
+
+      // Execute with tool loop (handles multi-turn tool calling)
+      // 'do'/'compress' = single round (maxRounds: 1), 'vibe' = multi-turn (maxRounds: 10)
+      const maxRetries = modelValue.maxRetriesOnError ?? 3;
+      const isDo = aiType === 'do' || aiType === 'compress';
+      const { response, rounds, returnFieldResults, completedViaReturnTool } = await executeWithTools(
+        request,
+        allTools,
+        state.rootDir,
+        (req) => withRetry(() => execute(req), { maxRetries }),
+        {
+          maxRounds: isDo ? 1 : 10,
+          expectedReturnTool: returnToolName ?? undefined,
+        }
+      );
+
+      // Convert tool rounds to PromptToolCall format for logging
+      // Filter out return tools - they're internal and shouldn't appear in context
+      const interactionToolCalls: PromptToolCall[] = rounds.flatMap((round) =>
+        round.toolCalls
+          .filter((call) => !isReturnToolCall(call.toolName))
+          .map((call) => {
+            const result = round.results.find((r) => r.toolCallId === call.id);
+            return {
+              toolName: call.toolName,
+              args: call.args,
+              result: result?.result,
+              error: result?.error,
+            };
+          })
+      );
+
+      // Determine final value
+      let finalValue: unknown;
+      if (useToolReturn) {
+        if (completedViaReturnTool && returnFieldResults) {
+          // Filter and validate field return results
+          const fieldResults = returnFieldResults.filter(isFieldReturnResult);
+          if (fieldResults.length === 0) {
+            throw new Error('No valid field return results from AI');
+          }
+          // Validate and collect all fields
+          const validated = collectAndValidateFieldResults(fieldResults, expectedFields!);
+          // For single-value returns, extract the 'value' field
+          // For multi-value destructuring, keep the whole object
+          finalValue = state.pendingDestructuring ? validated : validated['value'];
+        } else {
+          // After max retries, AI still didn't call return tool
+          throw new Error(`AI failed to call ${returnToolName} after multiple attempts`);
+        }
+      } else {
+        // Check if model used return tool anyway (even when not expected)
+        // This can happen since return tools are always included for caching
+        if (completedViaReturnTool && returnFieldResults) {
+          const fieldResults = returnFieldResults.filter(isFieldReturnResult);
+          if (fieldResults.length > 0) {
+            // Model used return tool - extract value from it
+            // Take the first field result's value (typically 'value' field)
+            finalValue = fieldResults[0].value;
+          } else {
+            finalValue = response.parsedValue ?? response.content;
+          }
+        } else {
+          finalValue = response.parsedValue ?? response.content;
+        }
+      }
+
+      // Return the parsed value, usage, tool rounds, and context for logging
+      return {
+        value: finalValue,
+        usage: response.usage,
+        toolRounds: rounds.length > 0 ? rounds : undefined,
+        // Context for logging (single source of truth)
+        messages: aiContext.messages,
+        executionContext: aiContext.executionContext,
+        interactionToolCalls: interactionToolCalls.length > 0 ? interactionToolCalls : undefined,
+      };
+    },
+
+    async generateCode(prompt: string): Promise<AIExecutionResult> {
+      // For vibe expressions, generate Vibe code using scope parameters
+      const state = getState();
+      if (!state.pendingAI) {
+        throw new Error('No pending AI request');
+      }
+
+      const modelName = state.pendingAI.model;
+      if (modelName === 'default') {
+        throw new Error('Vibe expressions require a model to be specified');
+      }
+
+      const modelValue = getModelValue(state, modelName);
+      if (!modelValue) {
+        throw new Error(`Model '${modelName}' not found in scope`);
+      }
+
+      // Build model config
+      const model = buildModelConfig(modelValue);
+
+      // Get scope parameters for vibe code generation
+      const scopeParams: VibeScopeParam[] = state.pendingAI.vibeScopeParams ?? [];
+
+      // Build vibe-specific messages with specialized system prompt
+      const vibeMessages = buildVibeMessages(prompt, scopeParams);
+
+      // Build the request for code generation (no tools, no structured output)
+      const request: AIRequest = {
+        operationType: 'vibe',
+        prompt,
+        contextText: '',  // Context is embedded in the vibe system prompt
+        targetType: null, // Raw text response expected
+        model,
+        // Override messages with vibe-specific format
+      };
+
+      // Get provider executor
+      const execute = getProviderExecutor(model.provider!);
+
+      // Execute directly without tool loop (vibe generates code, not tool calls)
+      const maxRetries = modelValue.maxRetriesOnError ?? 3;
+      const response = await withRetry(() => execute(request), { maxRetries });
+
+      // Log messages for debugging
+      const messages: AILogMessage[] = vibeMessages.map(m => ({
+        role: m.role,
+        content: m.content,
+      }));
+
+      return {
+        value: String(response.content),
+        usage: response.usage,
+        // Include vibe messages for logging
+        messages,
+        executionContext: [],  // Vibe doesn't use execution context
+      };
+    },
+
+    async askUser(prompt: string): Promise<string> {
+      // For user input, we could integrate with readline or similar
+      // For now, throw to indicate this needs external handling
+      throw new Error(
+        'User input not implemented. Use an external handler for awaiting_user state.'
+      );
+    },
+  };
+}
+
+/**
+ * A mock AI provider for testing (returns prompt as response).
+ */
+export function createMockAIProvider(): AIProvider {
+  return {
+    async execute(prompt: string): Promise<AIExecutionResult> {
+      return { value: `[AI Response to: ${prompt}]` };
+    },
+    async generateCode(prompt: string): Promise<AIExecutionResult> {
+      return { value: `// Generated code for: ${prompt}` };
+    },
+    async askUser(prompt: string): Promise<string> {
+      return `[User input for: ${prompt}]`;
+    },
+  };
+}