// types/index.ts

/**
 * Configuration for the static analyzer
 */
export interface AnalyzerConfig {
  provider: 'anthropic' | 'google' | 'openai';
  apiKey: string;
  model?: string;
  temperature?: number;
  maxTokens?: number;
}

/**
 * A segment of documentation to analyze
 */
export interface DocumentSegment {
  type: 'text' | 'code';
  content: string;
  language?: string;
  lineNumber: number;
}

/**
 * Result of analyzing a single segment
 */
export interface SegmentAnalysisResult {
  actions: ActionStep[];
  segment: DocumentSegment;
  metadata: {
    promptTokens: number;
    completionTokens: number;
    latencyMs: number;
  };
}

/**
 * Complete analysis result for a document
 */
export interface DocumentAnalysisResult {
  actions: ActionStep[];
  segments: SegmentAnalysisResult[];
  summary: {
    totalActions: number;
    totalSegments: number;
    analyzedSegments: number;
    skippedSegments: number;
    totalTokens: number;
    totalLatencyMs: number;
  };
}

/**
 * Base action step structure
 * (Extend with specific action types from schemas)
 */
export interface ActionStep {
  action: string;
  description: string;
  _source?: {
    type: 'text' | 'code';
    content: string;
    line: number;
  };
  _generated?: boolean;
  note?: string;
  confidence?: 'high' | 'medium' | 'low';
}

// analyzer/document-parser.ts

/**
 * Splits a document into analyzable segments while preserving
 * code blocks intact. Code blocks should not be analyzed as
 * instructions unless they contain shell commands.
 */
export function parseDocument(document: string): DocumentSegment[] {
  // Implementation requirements:
  // - Split on paragraph boundaries (double newlines)
  // - Preserve markdown code blocks (```language...```)
  // - Track line numbers for source attribution
  // - Handle nested structures (lists, blockquotes)
  // - Identify code blocks by language (bash/shell = analyze, others = skip)
}

/**
 * Determines if a code block contains executable instructions
 * that should be analyzed (e.g., shell commands).
 */
export function isAnalyzableCode(segment: DocumentSegment): boolean {
  // Return true for bash, sh, shell, zsh, fish
  // Return false for other languages
}

// analyzer/prompt-builder.ts

/**
 * Builds the core analysis prompt with high-recall bias
 */
export function buildCorePrompt(): string {
  // Return the CORE_ANALYSIS_PROMPT from the design
  // Include:
  // - Task definition
  // - Extraction philosophy (5 principles)
  // - Action decomposition examples
  // - Conditional logic handling
  // - Common patterns to watch for
  // - Output format requirements
}

/**
 * Builds static mode enhancement prompt
 */
export function buildStaticModePrompt(): string {
  // Return the STATIC_MODE_PROMPT from the design
  // Include guidance on:
  // - Aggressive inference strategies
  // - Placeholder variable usage
  // - Handling ambiguity
  // - Confidence scoring
}

/**
 * Gets relevant action schemas based on paragraph content
 */
export function getRelevantSchemas(
  paragraph: string,
  allSchemas: Record<string, object>
): string {
  // Detect likely action types using regex patterns
  // Return formatted schema documentation for detected types
  // Always include 'find' and 'conditional' schemas
}

/**
 * Builds the complete prompt for a paragraph
 */
export function buildPrompt(
  segment: DocumentSegment,
  schemas: Record<string, object>
): string {
  // Combine:
  // 1. Core prompt
  // 2. Static mode prompt
  // 3. Relevant schemas
  // 4. The segment content
  // 5. Output format reminder
}

// llm/provider.ts

import { generateText } from 'ai';
import { anthropic } from '@ai-sdk/anthropic';
import { google } from '@ai-sdk/google';
import { openai } from '@ai-sdk/openai';

/**
 * Creates an LLM provider instance based on configuration
 */
export function createProvider(config: AnalyzerConfig) {
  switch (config.provider) {
    case 'anthropic':
      return anthropic(config.model || 'claude-sonnet-4-20250514');
    case 'google':
      return google(config.model || 'gemini-2.0-flash-exp');
    case 'openai':
      return openai(config.model || 'gpt-4o');
    default:
      throw new Error(`Unsupported provider: ${config.provider}`);
  }
}

/**
 * Generates action steps for a segment using the configured LLM
 */
export async function analyzeSegment(
  segment: DocumentSegment,
  prompt: string,
  config: AnalyzerConfig
): Promise<{ actions: ActionStep[]; metadata: any }> {
  const startTime = Date.now();
  
  const model = createProvider(config);
  
  const result = await generateText({
    model,
    prompt,
    temperature: config.temperature ?? 0.3,
    maxTokens: config.maxTokens ?? 4000,
  });
  
  const latencyMs = Date.now() - startTime;
  
  // Parse JSON response
  let actions: ActionStep[] = [];
  try {
    actions = JSON.parse(result.text);
  } catch (error) {
    throw new Error(`Failed to parse LLM response: ${error.message}\nResponse: ${result.text}`);
  }
  
  return {
    actions,
    metadata: {
      promptTokens: result.usage?.promptTokens ?? 0,
      completionTokens: result.usage?.completionTokens ?? 0,
      latencyMs,
    },
  };
}

// analyzer/post-processor.ts

/**
 * Adds defensive find actions before click/typeKeys actions
 * to increase reliability and recall.
 */
export function addDefensiveActions(actions: ActionStep[]): ActionStep[] {
  // For each click action without preceding find:
  //   Insert find action with same selector
  // For each typeKeys action without preceding find:
  //   Insert find action with same selector
  // After significant actions (submit, save, login):
  //   Add verification find action
}

/**
 * Tags actions with source attribution for traceability
 */
export function tagActionsWithSource(
  actions: ActionStep[],
  segment: DocumentSegment
): ActionStep[] {
  // Add _source field to each action containing:
  // - segment type
  // - segment content
  // - line number
}

/**
 * Validates that generated actions conform to schemas
 */
export function validateActions(
  actions: ActionStep[],
  schemas: Record<string, object>
): { valid: ActionStep[]; invalid: any[] } {
  // Use JSON schema validation
  // Return valid actions and array of validation errors
}

// analyzer/index.ts

/**
 * Analyzes a complete document and returns extracted actions
 */
export async function analyzeDocument(
  document: string,
  config: AnalyzerConfig,
  schemas: Record<string, object>
): Promise<DocumentAnalysisResult> {
  // 1. Parse document into segments
  const segments = parseDocument(document);
  
  // 2. Analyze each segment
  const results: SegmentAnalysisResult[] = [];
  const allActions: ActionStep[] = [];
  
  for (const segment of segments) {
    // Skip non-analyzable code blocks
    if (segment.type === 'code' && !isAnalyzableCode(segment)) {
      continue;
    }
    
    // Skip empty segments
    if (!segment.content.trim()) {
      continue;
    }
    
    // Build prompt
    const prompt = buildPrompt(segment, schemas);
    
    // Call LLM
    const { actions, metadata } = await analyzeSegment(segment, prompt, config);
    
    // Tag actions with source
    const taggedActions = tagActionsWithSource(actions, segment);
    
    results.push({
      actions: taggedActions,
      segment,
      metadata,
    });
    
    allActions.push(...taggedActions);
  }
  
  // 3. Post-process actions
  const enhancedActions = addDefensiveActions(allActions);
  
  // 4. Validate actions
  const { valid, invalid } = validateActions(enhancedActions, schemas);
  
  if (invalid.length > 0) {
    console.warn(`${invalid.length} actions failed validation:`, invalid);
  }
  
  // 5. Build summary
  const summary = {
    totalActions: valid.length,
    totalSegments: segments.length,
    analyzedSegments: results.length,
    skippedSegments: segments.length - results.length,
    totalTokens: results.reduce((sum, r) => sum + r.metadata.promptTokens + r.metadata.completionTokens, 0),
    totalLatencyMs: results.reduce((sum, r) => sum + r.metadata.latencyMs, 0),
  };
  
  return {
    actions: valid,
    segments: results,
    summary,
  };
}

// index.ts

import { analyzeDocument } from './analyzer';
import * as schemas from './schemas';

/**
 * Main export: Static documentation analyzer
 */
export async function analyze(
  document: string,
  config: AnalyzerConfig
): Promise<DocumentAnalysisResult> {
  // Load schemas
  const actionSchemas = schemas.loadActionSchemas();
  
  // Run analysis
  return analyzeDocument(document, config, actionSchemas);
}

// Re-export types
export * from './types';

// schemas/index.ts

/**
 * Loads all action schemas from JSON files
 */
export function loadActionSchemas(): Record<string, object> {
  return {
    click: require('./actions/click.json'),
    typeKeys: require('./actions/typeKeys.json'),
    goTo: require('./actions/goTo.json'),
    find: require('./actions/find.json'),
    httpRequest: require('./actions/httpRequest.json'),
    runShell: require('./actions/runShell.json'),
    conditional: require('./actions/conditional.json'),
    // Add other action types as needed
  };
}

import { analyze } from '@doc-detective/resolver';

const documentation = `
Navigate to https://example.com and log in with your credentials.
Click the Settings button in the top navigation bar.
`;

const result = await analyze(documentation, {
  provider: 'anthropic',
  apiKey: process.env.ANTHROPIC_API_KEY!,
});

console.log(`Extracted ${result.summary.totalActions} actions`);
console.log(JSON.stringify(result.actions, null, 2));