import {
  createSecurityAnalyzer,
  createPerformanceAnalyzer,
  createAutoFix,
} from 'code-sherlock';

// Security Analysis
const security = createSecurityAnalyzer();
const securityResult = security.analyze([
  { path: 'src/api.ts', content: fileContent }
]);

console.log(security.formatAsMarkdown(securityResult));

// Performance Analysis
const perf = createPerformanceAnalyzer();
const perfResult = perf.analyze([
  { path: 'src/App.tsx', content: fileContent }
]);

console.log(`Score: ${perfResult.score}/100`);

// Auto-Fix Generation
const autofix = createAutoFix();
const fixes = await autofix.generateFixes({
  filePath: 'src/utils.ts',
  fileContent: code,
  language: 'typescript',
  comments: reviewComments,
});

import { createSecurityAnalyzer } from 'code-sherlock';

const analyzer = createSecurityAnalyzer({
  minSeverity: 'warning',
  enabledChecks: ['sql-injection', 'xss', 'hardcoded-secret'],
  includeLowConfidence: false,
});

const result = analyzer.analyze(files);

// Output:
// {
//   issues: [...],
//   summary: { critical: 2, high: 5, medium: 3, low: 1 },
//   filesAnalyzed: 10,
//   analysisTime: 150
// }

import { createPerformanceAnalyzer } from 'code-sherlock';

const analyzer = createPerformanceAnalyzer({
  focus: 'frontend', // 'backend' | 'both'
  minImpact: 'medium',
});

const result = analyzer.analyze(files);

console.log(`Performance Score: ${result.score}/100`);
// Score calculation: 100 - (high * 15) - (medium * 8) - (low * 3)

import { createAutoFix } from 'code-sherlock';

const autofix = createAutoFix();

const result = await autofix.generateFixes({
  filePath: 'src/api.ts',
  fileContent: sourceCode,
  language: 'typescript',
  comments: [
    { file: 'src/api.ts', line: 10, body: 'Add null check', severity: 'warning' }
  ],
});

// Format for GitHub PR
console.log(autofix.formatAsMarkdown(result.suggestions));

// Format as GitHub suggestion (clickable apply)
const suggestion = autofix.formatAsGitHubSuggestion(result.suggestions[0].fix);

import { createModelOrchestrator } from 'code-sherlock';

const orchestrator = createModelOrchestrator({
  models: [
    { provider: 'openai', model: 'gpt-4', apiKey: process.env.OPENAI_API_KEY },
    { provider: 'claude', model: 'claude-3-opus', apiKey: process.env.ANTHROPIC_API_KEY },
  ],
  strategy: 'parallel', // 'sequential' | 'fallback' | 'cascade'
  consensusThreshold: 0.6,
});

const result = await orchestrator.review(files, diff);

// Result includes consensus comments agreed upon by multiple models
console.log(result.consensus);

import { createOllamaProvider, isOllamaRunning, RECOMMENDED_MODELS } from 'code-sherlock';

// Check if Ollama is available
if (await isOllamaRunning()) {
  const provider = createOllamaProvider({
    model: 'codellama',  // or deepseek-coder, mistral, llama2
    baseUrl: 'http://localhost:11434',
    timeout: 120000,
  });

  const result = await provider.reviewCode(code, 'file.ts');
  console.log(result.bugs, result.security);
}

// List available models
const models = await provider.listModels();

import { createCodeExplainer, formatExplanationAsMarkdown } from 'code-sherlock';

const explainer = createCodeExplainer();

const explanation = await explainer.explain(code, 'service.ts', {
  detailLevel: 'detailed',  // 'brief' | 'normal' | 'detailed'
  audience: 'intermediate', // 'beginner' | 'intermediate' | 'expert'
});

// explanation includes:
// - summary: Brief overview
// - concepts: ['async/await', 'Classes', 'React Hooks']
// - patterns: ['Factory', 'Observer']
// - complexity: { level: 'moderate', factors: [...] }
// - dependencies: ['react', 'axios']

// Generate step-by-step walkthrough
const steps = explainer.walkthrough(code, 'service.ts');

// Format as markdown
const markdown = formatExplanationAsMarkdown(explanation);

import { createTestGenerator, formatTestsAsMarkdown } from 'code-sherlock';

const generator = createTestGenerator();

const result = await generator.generateTests(code, 'calculator.ts', {
  framework: 'jest',       // 'jest' | 'mocha' | 'vitest' | 'pytest'
  includeEdgeCases: true,
  includeMocks: true,
});

// result includes:
// - testFile: Complete test file content
// - tests: [{ name, code, type: 'happy-path' | 'edge-case' }]
// - imports: Required imports
// - mocks: Dependencies to mock
// - coverageEstimate: 85

console.log(result.testFile);  // Ready-to-use test file

import { createRedisAdapter } from 'code-sherlock';

const adapter = createRedisAdapter({
  url: 'redis://localhost:6379',
  prefix: 'sherlock:',
  ttl: 604800, // 7 days
});

// Use with ReviewCache
import { createReviewCacheWithAdapter } from 'code-sherlock';

const cache = createReviewCacheWithAdapter(adapter);
await cache.saveReview(review);