wiggum-cli 0.3.0 → 0.3.2

package/src/ai/enhancer.ts

@@ -3,13 +3,15 @@
  * Uses AI to analyze the codebase for deeper insights
  */
 
-import { generateText, stepCountIs } from 'ai';
+import { stepCountIs } from 'ai';
 import type { ScanResult, DetectedStack, DetectionResult } from '../scanner/types.js';
 import { getModel, type AIProvider, hasApiKey, getApiKeyEnvVar, isReasoningModel } from './providers.js';
 import { SYSTEM_PROMPT, SYSTEM_PROMPT_AGENTIC, createAnalysisPrompt } from './prompts.js';
 import { createExplorationTools } from './tools.js';
 import { runMultiAgentAnalysis, type MultiAgentAnalysis } from './agents/index.js';
 import { logger } from '../utils/logger.js';
+import { parseJsonSafe } from '../utils/json-repair.js';
+import { getTracedAI, traced } from '../utils/tracing.js';
 
 /**
  * Project context from AI analysis - key structure information
@@ -127,46 +129,26 @@ function parseAIResponse(text: string, verbose: boolean = false): AIAnalysisResu
     return null;
   }
 
-  try {
-    // Try to extract JSON from the response
-    // The AI might wrap it in markdown code blocks
-    let jsonText = text;
+  // Use safe JSON parser with repair capabilities
+  const result = parseJsonSafe<AIAnalysisResult>(text);
 
-    // Remove markdown code blocks if present
-    const jsonMatch = text.match(/```(?:json)?\s*([\s\S]*?)```/);
-    if (jsonMatch) {
-      jsonText = jsonMatch[1];
-    }
-
-    // Try to find JSON object - use greedy match for the outermost braces
-    // This handles cases where there's text before/after the JSON
-    const objectMatch = jsonText.match(/\{[\s\S]*\}/);
-    if (objectMatch) {
-      jsonText = objectMatch[0];
-    }
-
-    // Try to parse JSON
-    const result = JSON.parse(jsonText) as AIAnalysisResult;
-
-    // Validate that we got the expected structure
-    if (!result || typeof result !== 'object') {
-      if (verbose) {
-        logger.warn('AI response parsed but is not an object');
-      }
-      return null;
+  if (!result) {
+    if (verbose) {
+      logger.warn('Failed to parse AI response as JSON');
+      logger.warn(`Response preview: ${text.substring(0, 500)}...`);
     }
+    return null;
+  }
 
-    return result;
-  } catch (error) {
+  // Validate that we got the expected structure
+  if (typeof result !== 'object') {
     if (verbose) {
-      logger.warn(`Failed to parse AI response as JSON: ${error instanceof Error ? error.message : String(error)}`);
-      // Log first 500 chars of response for debugging
-      logger.warn(`Response preview: ${text.substring(0, 500)}...`);
-    } else {
-      logger.warn('Failed to parse AI response as JSON');
+      logger.warn('AI response parsed but is not an object');
     }
     return null;
   }
+
+  return result;
 }
 
 /**
@@ -310,6 +292,7 @@ export class AIEnhancer {
     scanResult: ScanResult
   ): Promise<AIAnalysisResult | null> {
     const prompt = createAnalysisPrompt(scanResult);
+    const { generateText } = getTracedAI();
 
     const { text } = await generateText({
       model,
@@ -318,6 +301,10 @@ export class AIEnhancer {
       maxOutputTokens: 2000,
       // Reasoning models don't support temperature
       ...(isReasoningModel(modelId) ? {} : { temperature: 0.3 }),
+      experimental_telemetry: {
+        isEnabled: true,
+        metadata: { phase: 'simple-analysis', projectRoot: scanResult.projectRoot },
+      },
     });
 
     return parseAIResponse(text);
@@ -361,6 +348,7 @@ export class AIEnhancer {
     scanResult: ScanResult
   ): Promise<AIAnalysisResult | null> {
     const tools = createExplorationTools(scanResult.projectRoot);
+    const { generateText } = getTracedAI();
 
     const prompt = `Analyze this codebase and produce configuration for AI-assisted development.
 
@@ -401,6 +389,10 @@ When done exploring, output your final analysis as valid JSON matching this stru
       stopWhen: stepCountIs(10),
       maxOutputTokens: 4000,
       ...(isReasoningModel(modelId) ? {} : { temperature: 0.3 }),
+      experimental_telemetry: {
+        isEnabled: true,
+        metadata: { phase: 'legacy-agentic', projectRoot: scanResult.projectRoot },
+      },
     });
 
     // Try to get text from the result

package/src/utils/json-repair.ts

@@ -0,0 +1,163 @@
+/**
+ * JSON Repair Utility
+ * Fixes common JSON syntax errors from AI responses
+ */
+
+/**
+ * Fix mismatched brackets in JSON
+ * AI sometimes writes } instead of ] or vice versa
+ */
+function fixMismatchedBrackets(text: string): string {
+  const chars = text.split('');
+  const stack: Array<{ char: string; index: number }> = [];
+  let inString = false;
+  let escapeNext = false;
+
+  for (let i = 0; i < chars.length; i++) {
+    const char = chars[i];
+
+    if (escapeNext) {
+      escapeNext = false;
+      continue;
+    }
+
+    if (char === '\\' && inString) {
+      escapeNext = true;
+      continue;
+    }
+
+    if (char === '"') {
+      inString = !inString;
+      continue;
+    }
+
+    if (inString) continue;
+
+    if (char === '{' || char === '[') {
+      stack.push({ char, index: i });
+    } else if (char === '}' || char === ']') {
+      if (stack.length > 0) {
+        const last = stack.pop()!;
+        const expected = last.char === '{' ? '}' : ']';
+        if (char !== expected) {
+          // Mismatch! Fix it
+          chars[i] = expected;
+        }
+      }
+    }
+  }
+
+  return chars.join('');
+}
+
+/**
+ * Attempt to repair malformed JSON from AI responses
+ */
+export function repairJson(text: string): string {
+  let json = text;
+
+  // Remove any leading/trailing whitespace
+  json = json.trim();
+
+  // Fix mismatched brackets (AI writes } instead of ] or vice versa)
+  json = fixMismatchedBrackets(json);
+
+  // Remove trailing commas before ] or }
+  json = json.replace(/,(\s*[\]}])/g, '$1');
+
+  // Fix missing commas between array elements or object properties
+  // Pattern: value followed by newline and another value without comma
+  json = json.replace(/("|\d|true|false|null|\]|\})(\s*\n\s*)("|\[|\{)/g, '$1,$2$3');
+
+  // Fix single quotes to double quotes (but not inside strings)
+  // This is a simplified approach - may not work for all cases
+  json = json.replace(/'/g, '"');
+
+  // Remove JavaScript-style comments
+  json = json.replace(/\/\/.*$/gm, '');
+  json = json.replace(/\/\*[\s\S]*?\*\//g, '');
+
+  // Fix unquoted keys (simple cases)
+  json = json.replace(/(\{|\,)\s*([a-zA-Z_][a-zA-Z0-9_]*)\s*:/g, '$1"$2":');
+
+  // Remove any text before the first { or [
+  const firstBrace = json.indexOf('{');
+  const firstBracket = json.indexOf('[');
+  let startIndex = -1;
+
+  if (firstBrace !== -1 && firstBracket !== -1) {
+    startIndex = Math.min(firstBrace, firstBracket);
+  } else if (firstBrace !== -1) {
+    startIndex = firstBrace;
+  } else if (firstBracket !== -1) {
+    startIndex = firstBracket;
+  }
+
+  if (startIndex > 0) {
+    json = json.substring(startIndex);
+  }
+
+  // Remove any text after the last } or ]
+  const lastBrace = json.lastIndexOf('}');
+  const lastBracket = json.lastIndexOf(']');
+  let endIndex = -1;
+
+  if (lastBrace !== -1 && lastBracket !== -1) {
+    endIndex = Math.max(lastBrace, lastBracket);
+  } else if (lastBrace !== -1) {
+    endIndex = lastBrace;
+  } else if (lastBracket !== -1) {
+    endIndex = lastBracket;
+  }
+
+  if (endIndex !== -1 && endIndex < json.length - 1) {
+    json = json.substring(0, endIndex + 1);
+  }
+
+  return json;
+}
+
+/**
+ * Parse JSON with repair attempts
+ * Tries to fix common issues before parsing
+ */
+export function parseJsonSafe<T>(text: string): T | null {
+  // First try parsing as-is
+  try {
+    return JSON.parse(text) as T;
+  } catch {
+    // Try with repairs
+  }
+
+  // Try repairing the JSON
+  try {
+    const repaired = repairJson(text);
+    return JSON.parse(repaired) as T;
+  } catch {
+    // Repair failed
+  }
+
+  // Last resort: try to extract JSON from markdown code blocks
+  const jsonMatch = text.match(/```(?:json)?\s*([\s\S]*?)```/);
+  if (jsonMatch) {
+    try {
+      const repaired = repairJson(jsonMatch[1]);
+      return JSON.parse(repaired) as T;
+    } catch {
+      // Still failed
+    }
+  }
+
+  // Try finding a JSON object
+  const objectMatch = text.match(/\{[\s\S]*\}/);
+  if (objectMatch) {
+    try {
+      const repaired = repairJson(objectMatch[0]);
+      return JSON.parse(repaired) as T;
+    } catch {
+      // Still failed
+    }
+  }
+
+  return null;
+}

package/src/utils/tracing.ts

@@ -0,0 +1,76 @@
+/**
+ * Braintrust Tracing Utility
+ * Provides AI call tracing for debugging and analysis
+ */
+
+import { initLogger, wrapAISDK } from 'braintrust';
+import * as ai from 'ai';
+
+// Re-export traced utilities
+export { traced, currentSpan, wrapTraced } from 'braintrust';
+
+/**
+ * Initialize Braintrust logger if API key is available
+ */
+let loggerInitialized = false;
+
+export function initTracing(): void {
+  if (loggerInitialized) return;
+
+  const apiKey = process.env.BRAINTRUST_API_KEY;
+  if (!apiKey) {
+    // Silently skip tracing if no API key
+    return;
+  }
+
+  try {
+    initLogger({
+      apiKey,
+      projectName: process.env.BRAINTRUST_PROJECT_NAME || 'wiggum-cli',
+    });
+    loggerInitialized = true;
+  } catch {
+    // Silently fail if tracing can't be initialized
+  }
+}
+
+/**
+ * Check if tracing is enabled
+ */
+export function isTracingEnabled(): boolean {
+  return !!process.env.BRAINTRUST_API_KEY;
+}
+
+/**
+ * Get wrapped AI SDK functions for automatic tracing
+ * Falls back to original functions if tracing not available
+ */
+export function getTracedAI() {
+  initTracing();
+
+  if (isTracingEnabled()) {
+    return wrapAISDK(ai);
+  }
+
+  // Return original AI SDK functions if tracing not enabled
+  return ai;
+}
+
+/**
+ * Wrap a function with tracing
+ * No-op if tracing is not enabled
+ */
+export function maybeTraced<T extends (...args: unknown[]) => unknown>(
+  fn: T,
+  options: { type?: string; name?: string } = {}
+): T {
+  if (!isTracingEnabled()) {
+    return fn;
+  }
+
+  const { wrapTraced } = require('braintrust');
+  return wrapTraced(fn, {
+    type: options.type || 'function',
+    name: options.name || fn.name || 'anonymous',
+  });
+}