ai-research-survey

data.ts (4599B)

---

 export interface ChecklistItem {
   category: string;
   question: string;
   applies: boolean;
   answer: boolean;
   justification: string;
 }
 
 export interface Claim {
   claim: string;
   supported: string;
 }
 
 export interface RedFlag {
   flag: string;
   detail: string;
 }
 
 export interface PaperIndex {
   id: string;
   title: string;
   year: number;
   venue: string;
   tags: string[];
   score: number | null;
   archetype: string | null;
   games: string[];
   arxiv_id: string;
   doi: string;
   code_url: string | null;
   dna: (number | null)[] | null;
   paper_type: string | null;
   engagement: (number | null)[] | null;
 }
 
 export interface PaperDetail extends PaperIndex {
   category_scores: Record<string, number>;
   claims: Claim[];
   red_flags: RedFlag[];
   checklist: ChecklistItem[];
   key_findings: string;
   active_modules: string[];
   source_url: string;
 }
 
 export interface HistBin {
   lo: number;
   hi: number;
   count: number;
 }
 
 export interface Pipeline {
   registry_total: number;
   v5_opus: number;
   v5_haiku: number;
   deprecated_scan: number;
   not_scanned: number;
 }
 
 export interface Dashboard {
   n: number;
   median: number;
   mean: number;
   full_reproducibility_pct: number;
   histogram: HistBin[];
   category_rates: Record<string, number>;
   year_trends: Record<string, { n: number; mean: number; median: number }>;
   game_pcts: Record<string, number>;
   archetype_counts: Record<string, number>;
   tag_counts: Record<string, number>;
   pipeline: Pipeline;
 }
 
 export interface QuestionRate {
   rate: number;
   n: number;
 }
 
 export interface GroupStat {
   n: number;
   mean: number;
   median: number;
 }
 
 export interface Findings {
   question_rates: Record<string, QuestionRate>;
   year_category_trends: Record<string, Record<string, number>>;
   venue_stats: Record<string, GroupStat>;
   citation_band_stats: Record<string, GroupStat>;
   optimism_rigor: Record<string, { positive_n: number; positive_mean: number; nuanced_n: number; nuanced_mean: number; gap: number }>;
   homophily: { threshold: number; baseline_pct: number; high_cite_high_pct: number; high_cite_total: number };
   sampling_effect: { checkpoints: { n: number; median: number }[] };
   benchmark_monoculture: Record<string, { benchmark_only: number; total: number; pct: number }>;
   funding_gap: Record<string, GroupStat>;
   repro_detail: Record<string, QuestionRate | number> & { full_pass_count: number; full_pass_pct: number };
   game_pcts: Record<string, number>;
   network_insights: {
     foundational: { id: string; title: string; in_degree: number; score: number | null }[];
     quality_contagion: Record<string, { n: number; mean: number }>;
     rigor_diffusion: { id: string; title: string; score: number | null; in_degree: number; citer_mean: number | null; citer_n: number }[];
   };
   correlation: {
     categories: string[];
     matrix: { r: number | null; n: number }[][];
   };
   pca: {
     points: { id: string; x: number; y: number; archetype: string; score: number }[];
     categories: string[];
     pc1_loadings: number[];
     pc2_loadings: number[];
     pc1_variance_pct: number;
     pc2_variance_pct: number;
   };
 }
 
 export interface TensionClaim {
   paper_id: string;
   claim: string;
   supported: string;
   score: number;
   year: number | null;
 }
 
 export interface TensionSides {
   positive: TensionClaim[];
   nuanced: TensionClaim[];
 }
 
 export interface Tensions {
   productivity: TensionSides;
   benchmarks: TensionSides;
   agents: TensionSides;
   security: TensionSides;
   code_quality: TensionSides;
   scaling: TensionSides;
   [key: string]: TensionSides;
 }
 
 export interface NetNode {
   id: string;
   title: string;
   score: number | null;
   year: number | null;
   in_degree: number;
   out_degree: number;
   has_scan: boolean;
 }
 
 export interface CitationNetwork {
   nodes: NetNode[];
   edges: [string, string][];
 }
 
 const cache: Record<string, unknown> = {};
 
 async function fetchJson<T>(path: string): Promise<T> {
   if (cache[path]) return cache[path] as T;
   const resp = await fetch(path);
   const data = await resp.json();
   cache[path] = data;
   return data as T;
 }
 
 export const loadDashboard = () => fetchJson<Dashboard>('/data/dashboard.json');
 export const loadFindings = () => fetchJson<Findings>('/data/findings.json');
 export const loadPapersIndex = () => fetchJson<PaperIndex[]>('/data/papers-index.json');
 export const loadPaperDetail = (slug: string) => fetchJson<PaperDetail>(`/data/papers/${slug}.json`);
 export const loadNetwork = () => fetchJson<CitationNetwork>('/data/network.json');
 export const loadTensions = () => fetchJson<Tensions>('/data/tensions.json');