skannr 0.1.1

package/src/benchmark.ts

@@ -0,0 +1,389 @@
+/**
+ * Benchmark script for code-analyzer
+ * Runs against a repository root to measure token reduction.
+ * Compares full-scan token cost vs skeletonized analysis across representative queries.
+ */
+
+import { analyzeProject } from './index';
+import { scanTypeScriptFiles } from './scanner';
+import { countTokens } from './tokenizer';
+import * as path from 'path';
+import * as fs from 'fs';
+
+interface BenchmarkScenario {
+  moduleKey: string;
+  query: string;
+  limit: number;
+}
+
+interface BenchmarkResult {
+  projectName: string;
+  projectRoot: string;
+  query: string;
+  // Baseline: what an LLM would consume reading ALL files
+  allFilesCount: number;
+  allFilesTotalTokens: number;
+  // Our tool output
+  analyzedFileCount: number;
+  analyzedOriginalTokens: number;
+  analyzedSkeletonTokens: number;
+  tokenReductionVsFullScan: number;   // skeleton vs full-repo scan
+  tokenReductionVsTopN: number;       // skeleton vs top-N original files
+  top1KeywordCoverage: number;
+  avgTopKKeywordCoverage: number;
+  pathIntentMatchRate: number;
+  directoryDiversity: number;
+  enhancedRanking: boolean;
+  executionTimeMs: number;
+  topFiles: {
+    path: string;
+    score: number;
+    originalTokens: number;
+    skeletonTokens: number;
+    reductionPct: number;
+  }[];
+}
+
+function extractQueryTerms(query: string): string[] {
+  return query
+    .toLowerCase()
+    .split(/[^a-z0-9]+/)
+    .filter(term => term.length > 2);
+}
+
+function computeKeywordCoverage(pathValue: string, skeleton: string, terms: string[]): number {
+  if (terms.length === 0) return 0;
+  const haystack = `${pathValue} ${skeleton}`.toLowerCase();
+  const hits = terms.filter(term => haystack.includes(term)).length;
+  return hits / terms.length;
+}
+
+function computeRankingQuality(
+  files: { path: string; skeleton: string }[],
+  query: string
+): {
+  top1KeywordCoverage: number;
+  avgTopKKeywordCoverage: number;
+  pathIntentMatchRate: number;
+  directoryDiversity: number;
+} {
+  if (files.length === 0) {
+    return {
+      top1KeywordCoverage: 0,
+      avgTopKKeywordCoverage: 0,
+      pathIntentMatchRate: 0,
+      directoryDiversity: 0,
+    };
+  }
+
+  const terms = extractQueryTerms(query);
+  const topK = files.slice(0, Math.min(5, files.length));
+  const coverages = topK.map(file => computeKeywordCoverage(file.path, file.skeleton, terms));
+
+  const top1KeywordCoverage = coverages[0] ?? 0;
+  const avgTopKKeywordCoverage = coverages.reduce((sum, value) => sum + value, 0) / topK.length;
+
+  const pathIntentMatches = topK.filter(file =>
+    terms.some(term => file.path.toLowerCase().includes(term))
+  ).length;
+  const pathIntentMatchRate = pathIntentMatches / topK.length;
+
+  const uniqueDirs = new Set(
+    topK.map(file => path.dirname(file.path).toLowerCase())
+  );
+  const directoryDiversity = uniqueDirs.size / topK.length;
+
+  return {
+    top1KeywordCoverage,
+    avgTopKKeywordCoverage,
+    pathIntentMatchRate,
+    directoryDiversity,
+  };
+}
+
+export const BENCHMARK_SCENARIOS: BenchmarkScenario[] = [
+  { moduleKey: 'src', query: 'authentication flow and permission checks', limit: 10 },
+  { moduleKey: 'lib', query: 'database connection management', limit: 10 },
+  { moduleKey: 'packages', query: 'API endpoint and routing structure', limit: 10 },
+];
+
+/**
+ * Quickly sum tokens across all .ts/.tsx files in a directory.
+ * Uses a capped sample to stay fast, then extrapolates.
+ */
+function sampleDirectoryTokens(
+  rootPath: string,
+  maxFiles = 50
+): { fileCount: number; totalTokens: number; isSampled: boolean } {
+  const allFiles = scanTypeScriptFiles(rootPath);
+  const isSampled = allFiles.length > maxFiles;
+  const filesToRead = isSampled ? allFiles.slice(0, maxFiles) : allFiles;
+
+  let totalTokens = 0;
+  for (const f of filesToRead) {
+    try {
+      const content = fs.readFileSync(f, 'utf-8');
+      totalTokens += countTokens(content);
+    } catch {
+      // skip unreadable
+    }
+  }
+
+  const estimatedTotal = isSampled
+    ? Math.round((totalTokens / filesToRead.length) * allFiles.length)
+    : totalTokens;
+
+  return { fileCount: allFiles.length, totalTokens: estimatedTotal, isSampled };
+}
+
+/**
+ * Run a single benchmark scenario
+ */
+async function benchmarkProject(
+  appRoot: string,
+  moduleKey: string,
+  projectName: string,
+  query: string,
+  options: { limit?: number; enhancedRanking?: boolean } = {}
+): Promise<BenchmarkResult> {
+  const limit = options.limit ?? 10;
+  const moduleFullPath = fs.existsSync(path.join(appRoot, moduleKey))
+    ? path.join(appRoot, moduleKey)
+    : appRoot;
+
+  // Baseline: estimate full-module token cost (what we are comparing against)
+  const baseline = sampleDirectoryTokens(moduleFullPath, 200);
+
+  const start = Date.now();
+  const result = await analyzeProject({
+    root: appRoot,
+    question: query,
+    limit,
+    enhancedRanking: options.enhancedRanking ?? true,
+    moduleKeys: [moduleKey],
+    generateMapping: false,
+  });
+  const executionTimeMs = Date.now() - start;
+
+  let analyzedOriginal = 0;
+  let analyzedSkeleton = 0;
+
+  const topFiles = result.files.map(f => {
+    analyzedOriginal += f.originalTokenCount;
+    analyzedSkeleton += f.skeletonTokenCount;
+    return {
+      path: f.path,
+      score: f.score,
+      originalTokens: f.originalTokenCount,
+      skeletonTokens: f.skeletonTokenCount,
+      reductionPct:
+        f.originalTokenCount > 0
+          ? ((f.originalTokenCount - f.skeletonTokenCount) / f.originalTokenCount) * 100
+          : 0,
+    };
+  });
+
+  const tokenReductionVsFullScan =
+    baseline.totalTokens > 0
+      ? ((baseline.totalTokens - analyzedSkeleton) / baseline.totalTokens) * 100
+      : 0;
+
+  const tokenReductionVsTopN =
+    analyzedOriginal > 0
+      ? ((analyzedOriginal - analyzedSkeleton) / analyzedOriginal) * 100
+      : 0;
+
+  const rankingQuality = computeRankingQuality(
+    result.files.map(file => ({ path: file.path, skeleton: file.skeleton })),
+    query
+  );
+
+  return {
+    projectName,
+    projectRoot: moduleFullPath,
+    query,
+    allFilesCount: baseline.fileCount,
+    allFilesTotalTokens: baseline.totalTokens,
+    analyzedFileCount: result.files.length,
+    analyzedOriginalTokens: analyzedOriginal,
+    analyzedSkeletonTokens: analyzedSkeleton,
+    tokenReductionVsFullScan,
+    tokenReductionVsTopN,
+    top1KeywordCoverage: rankingQuality.top1KeywordCoverage,
+    avgTopKKeywordCoverage: rankingQuality.avgTopKKeywordCoverage,
+    pathIntentMatchRate: rankingQuality.pathIntentMatchRate,
+    directoryDiversity: rankingQuality.directoryDiversity,
+    enhancedRanking: options.enhancedRanking ?? true,
+    executionTimeMs,
+    topFiles,
+  };
+}
+
+/**
+ * Format results for console output
+ */
+function formatResults(results: BenchmarkResult[]): string {
+  const lines: string[] = [];
+
+  lines.push('═══════════════════════════════════════════════════════════════════════');
+  lines.push('          CODE ANALYZER BENCHMARK — Generic Repository');
+  lines.push('═══════════════════════════════════════════════════════════════════════\n');
+
+  for (const r of results) {
+    lines.push(`\n📊  ${r.projectName}`);
+    lines.push(`    Query: "${r.query}"`);
+    lines.push('');
+    lines.push(`    🗂  Repository Baseline (naive full-scan):`);
+    lines.push(`        Total .ts/.tsx files : ${r.allFilesCount.toLocaleString()}`);
+    lines.push(`        Estimated tokens     : ${r.allFilesTotalTokens.toLocaleString()}`);
+    lines.push('');
+    lines.push(`    ⚙️  Our Tool (top ${r.analyzedFileCount} files, enhanced ranking: ${r.enhancedRanking ? '✓' : '✗'}):`);
+    lines.push(`        Original tokens sent : ${r.analyzedOriginalTokens.toLocaleString()}`);
+    lines.push(`        Skeleton tokens sent : ${r.analyzedSkeletonTokens.toLocaleString()}`);
+    lines.push(`        Reduction vs full scan  : ${r.tokenReductionVsFullScan.toFixed(1)}% ⬇️`);
+    lines.push(`        Reduction vs top-N raw  : ${r.tokenReductionVsTopN.toFixed(1)}% ⬇️`);
+    lines.push(`        Top-1 keyword coverage  : ${(r.top1KeywordCoverage * 100).toFixed(1)}%`);
+    lines.push(`        Avg top-K coverage      : ${(r.avgTopKKeywordCoverage * 100).toFixed(1)}%`);
+    lines.push(`        Path intent match rate  : ${(r.pathIntentMatchRate * 100).toFixed(1)}%`);
+    lines.push(`        Directory diversity     : ${(r.directoryDiversity * 100).toFixed(1)}%`);
+    lines.push(`        Execution time          : ${r.executionTimeMs}ms`);
+    lines.push('');
+    lines.push(`    📁  Top Ranked Files:`);
+    for (let i = 0; i < Math.min(5, r.topFiles.length); i++) {
+      const f = r.topFiles[i];
+      lines.push(
+        `        ${i + 1}. ${f.path}`
+      );
+      lines.push(
+        `           Score: ${f.score.toFixed(3)}  |  ${f.originalTokens} → ${f.skeletonTokens} tokens  (${f.reductionPct.toFixed(1)}% ⬇️)`
+      );
+    }
+    lines.push('');
+    lines.push('───────────────────────────────────────────────────────────────────────');
+  }
+
+  // Summary
+  const avgReductionFullScan =
+    results.reduce((s, r) => s + r.tokenReductionVsFullScan, 0) / results.length;
+  const avgReductionTopN =
+    results.reduce((s, r) => s + r.tokenReductionVsTopN, 0) / results.length;
+  const avgTop1Coverage =
+    results.reduce((s, r) => s + r.top1KeywordCoverage, 0) / results.length;
+  const avgTopKCoverage =
+    results.reduce((s, r) => s + r.avgTopKKeywordCoverage, 0) / results.length;
+  const avgPathIntentMatch =
+    results.reduce((s, r) => s + r.pathIntentMatchRate, 0) / results.length;
+  const avgTime =
+    results.reduce((s, r) => s + r.executionTimeMs, 0) / results.length;
+
+  lines.push('\n📊  SUMMARY');
+  lines.push('───────────────────────────────────────────────────────────────────────');
+  lines.push(`    Benchmarks run               : ${results.length}`);
+  lines.push(`    Avg reduction vs full scan   : ${avgReductionFullScan.toFixed(1)}%`);
+  lines.push(`    Avg reduction vs top-N raw   : ${avgReductionTopN.toFixed(1)}%`);
+  lines.push(`    Avg top-1 coverage           : ${(avgTop1Coverage * 100).toFixed(1)}%`);
+  lines.push(`    Avg top-K coverage           : ${(avgTopKCoverage * 100).toFixed(1)}%`);
+  lines.push(`    Avg path intent match rate   : ${(avgPathIntentMatch * 100).toFixed(1)}%`);
+  lines.push(`    Avg execution time           : ${avgTime.toFixed(0)}ms`);
+  lines.push('═══════════════════════════════════════════════════════════════════════\n');
+
+  return lines.join('\n');
+}
+
+/**
+ * Save benchmark output to JSON
+ */
+function saveResults(results: BenchmarkResult[], outputPath: string): void {
+  const out = {
+    generatedAt: new Date().toISOString(),
+    root: results[0]?.projectRoot ?? '',
+    summary: {
+      avgReductionVsFullScan:
+        results.reduce((s, r) => s + r.tokenReductionVsFullScan, 0) / results.length,
+      avgReductionVsTopN:
+        results.reduce((s, r) => s + r.tokenReductionVsTopN, 0) / results.length,
+      avgTop1KeywordCoverage:
+        results.reduce((s, r) => s + r.top1KeywordCoverage, 0) / results.length,
+      avgTopKKeywordCoverage:
+        results.reduce((s, r) => s + r.avgTopKKeywordCoverage, 0) / results.length,
+      avgPathIntentMatchRate:
+        results.reduce((s, r) => s + r.pathIntentMatchRate, 0) / results.length,
+      avgExecutionTimeMs:
+        results.reduce((s, r) => s + r.executionTimeMs, 0) / results.length,
+    },
+    benchmarks: results,
+  };
+  fs.writeFileSync(outputPath, JSON.stringify(out, null, 2), 'utf-8');
+  console.log(`\n✅  Results saved → ${outputPath}`);
+}
+
+/**
+ * Main entry point
+ */
+async function runBenchmarks(): Promise<void> {
+  const repoRoot = process.cwd();
+
+  // Verify repo exists
+  if (!fs.existsSync(repoRoot)) {
+    console.error(`❌  Repository not found at ${repoRoot}`);
+    process.exit(1);
+  }
+
+  const appRoot = repoRoot;
+  console.log('🚀  Code Analyzer — Generic Repository Benchmarks\n');
+  console.log(`    Repo : ${repoRoot}`);
+  console.log('    Computing baseline (first 50 files sample)...');
+  const fullBaseline = sampleDirectoryTokens(appRoot, 50);
+  console.log(`    Baseline → ${fullBaseline.fileCount} .ts files, ` +
+    `~${fullBaseline.totalTokens.toLocaleString()} tokens (${fullBaseline.isSampled ? 'extrapolated' : 'exact'})\n`);
+
+  const results: BenchmarkResult[] = [];
+
+  let i = 1;
+  for (const scenario of BENCHMARK_SCENARIOS) {
+    console.log(`▶  [${i}/${BENCHMARK_SCENARIOS.length}] ${scenario.query} (${scenario.moduleKey})`);
+    results.push(await benchmarkProject(
+      repoRoot,
+      scenario.moduleKey,
+      `Repo › ${scenario.moduleKey}`,
+      scenario.query,
+      { limit: scenario.limit, enhancedRanking: true }
+    ));
+    console.log(`   ✓ ${results.at(-1)!.executionTimeMs}ms\n`);
+    i++;
+  }
+
+  // ── Output ────────────────────────────────────────────────────────────────────
+  console.log(formatResults(results));
+
+  // Append full-app baseline note to the formatted output
+  console.log(`ℹ️  Full app/ baseline (naive full-scan):`);
+  console.log(`    ${fullBaseline.fileCount} files  →  ~${fullBaseline.totalTokens.toLocaleString()} tokens`);
+  console.log(`    vs our tool avg skeleton: ~${Math.round(results.reduce((s, r) => s + r.analyzedSkeletonTokens, 0) / results.length).toLocaleString()} tokens per query\n`);
+
+  const outputPath = path.join(__dirname, '..', 'benchmark-results.json');
+  // Attach baseline to JSON output
+  const extendedResults = {
+    fullAppBaseline: {
+      root: appRoot,
+      fileCount: fullBaseline.fileCount,
+      estimatedTotalTokens: fullBaseline.totalTokens,
+      isSampled: fullBaseline.isSampled,
+    },
+    benchmarks: results,
+  };
+  fs.writeFileSync(outputPath, JSON.stringify(extendedResults, null, 2), 'utf-8');
+  console.log(`✅  Saved → ${outputPath}`);
+}
+
+// ── Run ───────────────────────────────────────────────────────────────────────
+if (require.main === module) {
+  runBenchmarks()
+    .then(() => process.exit(0))
+    .catch(err => {
+      console.error('❌  Benchmark failed:', err);
+      process.exit(1);
+    });
+}
+
+export { benchmarkProject, formatResults, saveResults };

package/src/cache.ts

@@ -0,0 +1,317 @@
+/**
+ * Caching system for code analysis results
+ * Uses hybrid approach: in-memory + disk cache with MD5 file validation
+ */
+
+import * as fs from 'fs';
+import * as path from 'path';
+import * as crypto from 'crypto';
+import { AnalysisResult } from './types';
+
+export interface CacheConfig {
+  enabled: boolean;
+  inMemory: boolean;
+  onDisk: boolean;
+  cacheDir: string;
+}
+
+export interface CacheEntry {
+  result: AnalysisResult;
+  fileHashes: Record<string, string>; // filename -> md5 hash
+  createdAt: number;
+  expiresAt: number;
+}
+
+/**
+ * Default cache configuration
+ */
+export const DEFAULT_CACHE_CONFIG: CacheConfig = {
+  enabled: true,
+  inMemory: true,
+  onDisk: true,
+  cacheDir: path.join(process.cwd(), '.code-analyzer-cache'),
+};
+
+/**
+ * Cache manager for analysis results
+ */
+export class CacheManager {
+  private config: CacheConfig;
+  private memoryCache: Map<string, CacheEntry> = new Map();
+  private stats = {
+    hits: 0,
+    misses: 0,
+    invalidations: 0,
+  };
+
+  constructor(config: Partial<CacheConfig> = {}) {
+    this.config = { ...DEFAULT_CACHE_CONFIG, ...config };
+
+    if (this.config.onDisk && !fs.existsSync(this.config.cacheDir)) {
+      fs.mkdirSync(this.config.cacheDir, { recursive: true });
+    }
+  }
+
+  /**
+   * Generate cache key from analysis parameters
+   */
+  private generateKey(
+    root: string,
+    question: string,
+    moduleKeys?: string[],
+    enhancedRanking?: boolean,
+    limit?: number
+  ): string {
+    const input = `${root}|${question}|${(moduleKeys || []).join(',')}|${enhancedRanking}|${limit}`;
+    return crypto.createHash('md5').update(input).digest('hex');
+  }
+
+  /**
+   * Calculate MD5 hash of file contents
+   */
+  private hashFile(filePath: string): string | null {
+    try {
+      const content = fs.readFileSync(filePath, 'utf-8');
+      return crypto.createHash('md5').update(content).digest('hex');
+    } catch {
+      return null;
+    }
+  }
+
+  /**
+   * Hash all files in a directory (for change detection)
+   */
+  private hashFiles(fileList: string[]): Record<string, string> {
+    const hashes: Record<string, string> = {};
+
+    for (const filePath of fileList) {
+      const hash = this.hashFile(filePath);
+      if (hash) {
+        hashes[filePath] = hash;
+      }
+    }
+
+    return hashes;
+  }
+
+  /**
+   * Check if cached entry is still valid (files haven't changed)
+   */
+  private isValidEntry(entry: CacheEntry, fileList: string[]): boolean {
+    // Check expiration (24 hours)
+    if (Date.now() > entry.expiresAt) {
+      return false;
+    }
+
+    // Check if any files have changed
+    for (const filePath of fileList) {
+      const currentHash = this.hashFile(filePath);
+      const cachedHash = entry.fileHashes[filePath];
+
+      if (!currentHash || currentHash !== cachedHash) {
+        return false;
+      }
+    }
+
+    // Check if files were added/removed
+    if (Object.keys(entry.fileHashes).length !== fileList.length) {
+      return false;
+    }
+
+    return true;
+  }
+
+  /**
+   * Get cached result
+   */
+  get(
+    root: string,
+    question: string,
+    analyzedFiles: string[],
+    moduleKeys?: string[],
+    enhancedRanking?: boolean,
+    limit?: number
+  ): AnalysisResult | null {
+    if (!this.config.enabled) {
+      return null;
+    }
+
+    const key = this.generateKey(root, question, moduleKeys, enhancedRanking, limit);
+
+    // Try memory cache first
+    if (this.config.inMemory) {
+      const memEntry = this.memoryCache.get(key);
+      if (memEntry && this.isValidEntry(memEntry, analyzedFiles)) {
+        this.stats.hits++;
+        return memEntry.result;
+      }
+    }
+
+    // Try disk cache
+    if (this.config.onDisk) {
+      const diskEntry = this.loadFromDisk(key);
+      if (diskEntry && this.isValidEntry(diskEntry, analyzedFiles)) {
+        this.stats.hits++;
+
+        // Restore to memory cache
+        if (this.config.inMemory) {
+          this.memoryCache.set(key, diskEntry);
+        }
+
+        return diskEntry.result;
+      }
+    }
+
+    this.stats.misses++;
+    return null;
+  }
+
+  /**
+   * Save result to cache
+   */
+  set(
+    root: string,
+    question: string,
+    analyzedFiles: string[],
+    result: AnalysisResult,
+    moduleKeys?: string[],
+    enhancedRanking?: boolean,
+    limit?: number
+  ): void {
+    if (!this.config.enabled) {
+      return;
+    }
+
+    const key = this.generateKey(root, question, moduleKeys, enhancedRanking, limit);
+    const fileHashes = this.hashFiles(analyzedFiles);
+
+    const entry: CacheEntry = {
+      result,
+      fileHashes,
+      createdAt: Date.now(),
+      expiresAt: Date.now() + 24 * 60 * 60 * 1000, // 24 hours
+    };
+
+    // Save to memory cache
+    if (this.config.inMemory) {
+      this.memoryCache.set(key, entry);
+    }
+
+    // Save to disk cache
+    if (this.config.onDisk) {
+      this.saveToDisk(key, entry);
+    }
+  }
+
+  /**
+   * Load cache entry from disk
+   */
+  private loadFromDisk(key: string): CacheEntry | null {
+    try {
+      const cacheFile = path.join(this.config.cacheDir, `${key}.json`);
+      if (!fs.existsSync(cacheFile)) {
+        return null;
+      }
+
+      const content = fs.readFileSync(cacheFile, 'utf-8');
+      return JSON.parse(content) as CacheEntry;
+    } catch {
+      return null;
+    }
+  }
+
+  /**
+   * Save cache entry to disk
+   */
+  private saveToDisk(key: string, entry: CacheEntry): void {
+    try {
+      const cacheFile = path.join(this.config.cacheDir, `${key}.json`);
+      fs.writeFileSync(cacheFile, JSON.stringify(entry, null, 2), 'utf-8');
+    } catch (error) {
+      console.warn(`Failed to save cache to disk: ${error instanceof Error ? error.message : 'Unknown error'}`);
+    }
+  }
+
+  /**
+   * Clear all caches
+   */
+  clear(): void {
+    // Clear memory cache
+    this.memoryCache.clear();
+
+    // Clear disk cache
+    if (this.config.onDisk && fs.existsSync(this.config.cacheDir)) {
+      try {
+        fs.rmSync(this.config.cacheDir, { recursive: true, force: true });
+        fs.mkdirSync(this.config.cacheDir, { recursive: true });
+      } catch (error) {
+        console.warn(`Failed to clear disk cache: ${error instanceof Error ? error.message : 'Unknown error'}`);
+      }
+    }
+
+    // Reset stats
+    this.stats = { hits: 0, misses: 0, invalidations: 0 };
+  }
+
+  /**
+   * Clear memory cache only
+   */
+  clearMemory(): void {
+    this.memoryCache.clear();
+  }
+
+  /**
+   * Get cache statistics
+   */
+  getStats(): { hits: number; misses: number; invalidations: number; hitRate: number; cacheSize: number } {
+    const total = this.stats.hits + this.stats.misses;
+    const hitRate = total > 0 ? (this.stats.hits / total) * 100 : 0;
+
+    let cacheSize = 0;
+    if (this.config.onDisk && fs.existsSync(this.config.cacheDir)) {
+      const files = fs.readdirSync(this.config.cacheDir);
+      for (const file of files) {
+        const stat = fs.statSync(path.join(this.config.cacheDir, file));
+        cacheSize += stat.size;
+      }
+    }
+
+    return {
+      hits: this.stats.hits,
+      misses: this.stats.misses,
+      invalidations: this.stats.invalidations,
+      hitRate: Math.round(hitRate * 100) / 100,
+      cacheSize,
+    };
+  }
+
+  /**
+   * Get cache directory path
+   */
+  getCacheDir(): string {
+    return this.config.cacheDir;
+  }
+}
+
+/**
+ * Global cache manager instance
+ */
+export let globalCacheManager: CacheManager | null = null;
+
+/**
+ * Initialize global cache manager
+ */
+export function initializeCacheManager(config?: Partial<CacheConfig>): CacheManager {
+  globalCacheManager = new CacheManager(config);
+  return globalCacheManager;
+}
+
+/**
+ * Get or create global cache manager
+ */
+export function getCacheManager(): CacheManager {
+  if (!globalCacheManager) {
+    globalCacheManager = new CacheManager();
+  }
+  return globalCacheManager;
+}