autoscholar-cli 1.0.0

package/dist/agents/fisher.js

@@ -0,0 +1,348 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runFisher = runFisher;
+const ora_1 = __importDefault(require("ora"));
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const llm_1 = require("../utils/llm");
+const banner_1 = require("../cli/banner");
+const project_1 = require("../utils/project");
+const runner_1 = require("../python/runner");
+async function runFisher(topic, method, projectId, config, logger, datasetInfo, gapAnalysis) {
+    const spinner = (0, ora_1.default)({ text: 'Fisher: Designing empirical analysis...', indent: 2 }).start();
+    logger.info(`[FISHER] Starting analysis — method: ${method || 'auto'}, dataset: ${datasetInfo.rows} rows`);
+    const projectDir = (0, project_1.getProjectDir)(projectId);
+    const figuresDir = path.join(projectDir, 'output', 'figures');
+    if (!fs.existsSync(figuresDir))
+        fs.mkdirSync(figuresDir, { recursive: true });
+    spinner.text = 'Fisher: Designing econometric models...';
+    const analysisCode = await (0, llm_1.callLLM)(config, `You are Fisher, the empirical analysis agent of AutoScholar.
+
+Write a comprehensive Python analysis script that:
+
+1. LOADS the dataset from the given path
+2. RUNS the appropriate econometric/statistical models based on the topic and method
+3. GENERATES publication-quality figures (at least 8-10 figures)
+4. CREATES LaTeX-formatted tables
+5. RUNS diagnostic tests
+6. PRINTS structured JSON results at the end
+
+Available libraries (always installed):
+- pandas, numpy, scipy, scikit-learn, statsmodels
+- matplotlib (use Agg backend), seaborn
+- arch (for GARCH models)
+- linearmodels (for panel data, IV)
+
+Figure requirements:
+- Use matplotlib with Agg backend: import matplotlib; matplotlib.use('Agg')
+- Use seaborn style: sns.set_theme(style='whitegrid', font_scale=1.2)
+- Save all figures to: ${figuresDir}/
+- Use tight_layout() and savefig with dpi=300, bbox_inches='tight'
+- Include proper titles, axis labels, legends
+
+Table requirements:
+- Format as LaTeX booktabs tables
+- Include standard errors in parentheses
+- Mark significance: *** p<0.01, ** p<0.05, * p<0.10
+
+Model selection guide:
+- Time series: GARCH, DCC-GARCH, VAR, VECM
+- Cross-section: OLS, robust SE, quantile regression
+- Panel: Fixed effects, random effects, Hausman test
+- ML: Random Forest, XGBoost with SHAP
+
+At the END, print a JSON object with this structure:
+{
+  "models": [{"name": "OLS", "type": "regression", "coefficients": {}, "standardErrors": {}, "rSquared": 0.85, "pValues": {}, "diagnostics": [], "significant": true}],
+  "figures": [{"filename": "fig1.png", "caption": "Time series plot"}],
+  "tables": [{"name": "Table 1", "latex": "\\\\begin{table}...", "caption": "Regression results"}],
+  "summary": "Brief summary of key findings",
+  "diagnostics": ["VIF < 5 for all variables", "No autocorrelation (DW = 2.01)"]
+}
+
+Write ONLY Python code. Start with imports.`, `Research topic: ${topic}
+Method: ${method || 'auto-detect based on data'}
+Dataset path: ${datasetInfo.finalDatasetPath}
+Columns: ${datasetInfo.columns.join(', ')}
+Rows: ${datasetInfo.rows}
+Data dictionary: ${JSON.stringify(datasetInfo.dataDictionary)}
+${gapAnalysis?.recommendedGap ? `Research gap: ${gapAnalysis.recommendedGap.title}\nSuggested approach: ${gapAnalysis.recommendedGap.suggestedApproach}` : ''}`, { maxTokens: 16384, model: 'claude-sonnet-4-20250514' });
+    let pythonCode = analysisCode;
+    const codeMatch = analysisCode.match(/```python\s*\n?([\s\S]*?)```/);
+    if (codeMatch) {
+        pythonCode = codeMatch[1];
+    }
+    (0, project_1.saveProjectFile)(projectId, 'code/fisher_analysis.py', pythonCode);
+    spinner.text = 'Fisher: Running econometric analysis...';
+    logger.info(`[FISHER] Executing analysis script`);
+    const pyResult = await (0, runner_1.runPython)(pythonCode, projectDir, 300000);
+    if (!pyResult.success) {
+        logger.warn(`[FISHER] First attempt failed: ${pyResult.error}`);
+        spinner.text = 'Fisher: Retrying with simplified analysis...';
+        const simpleCode = await generateSimplifiedAnalysis(topic, method, datasetInfo, figuresDir, config);
+        (0, project_1.saveProjectFile)(projectId, 'code/fisher_analysis_v2.py', simpleCode);
+        const retryResult = await (0, runner_1.runPython)(simpleCode, projectDir, 300000);
+        if (!retryResult.success) {
+            spinner.stop();
+            logger.error(`[FISHER] Retry failed: ${retryResult.error}`);
+            return {
+                success: false, models: [], figures: [], tables: [],
+                summary: 'Analysis failed', diagnostics: [],
+            };
+        }
+        return parseFisherOutput(retryResult.output, figuresDir, logger, spinner);
+    }
+    return parseFisherOutput(pyResult.output, figuresDir, logger, spinner);
+}
+function parseFisherOutput(output, figuresDir, logger, spinner) {
+    spinner.stop();
+    const jsonMatch = output.match(/\{[\s\S]*"models"[\s\S]*\}/);
+    if (jsonMatch) {
+        try {
+            const result = JSON.parse(jsonMatch[0]);
+            const figureFiles = fs.existsSync(figuresDir)
+                ? fs.readdirSync(figuresDir).filter((f) => /\.(png|pdf|svg)$/i.test(f))
+                : [];
+            const figures = (result.figures || []).map((f) => ({
+                ...f,
+                path: path.join(figuresDir, f.filename),
+            }));
+            for (const file of figureFiles) {
+                if (!figures.find((f) => f.filename === file)) {
+                    figures.push({
+                        filename: file,
+                        caption: file.replace(/\.[^.]+$/, '').replace(/[_-]/g, ' '),
+                        path: path.join(figuresDir, file),
+                    });
+                }
+            }
+            (0, banner_1.printSuccess)(`Analysis complete: ${(result.models || []).length} models estimated`);
+            (0, banner_1.printSuccess)(`${figures.length} figures generated`);
+            if (result.summary)
+                (0, banner_1.printInfo)(result.summary);
+            for (const diag of (result.diagnostics || []).slice(0, 5)) {
+                (0, banner_1.printInfo)(`  Diagnostic: ${diag}`);
+            }
+            logger.info(`[FISHER] Complete — ${(result.models || []).length} models, ${figures.length} figures`);
+            return {
+                success: true,
+                models: result.models || [],
+                figures,
+                tables: result.tables || [],
+                summary: result.summary || '',
+                diagnostics: result.diagnostics || [],
+            };
+        }
+        catch (err) {
+            logger.warn(`[FISHER] JSON parse error: ${err}`);
+        }
+    }
+    const figureFiles = fs.existsSync(figuresDir)
+        ? fs.readdirSync(figuresDir).filter((f) => /\.(png|pdf|svg)$/i.test(f))
+        : [];
+    (0, banner_1.printSuccess)(`Analysis complete (partial): ${figureFiles.length} figures found`);
+    logger.info(`[FISHER] Partial completion — ${figureFiles.length} figures`);
+    return {
+        success: figureFiles.length > 0,
+        models: [],
+        figures: figureFiles.map((f) => ({
+            filename: f,
+            caption: f.replace(/\.[^.]+$/, '').replace(/[_-]/g, ' '),
+            path: path.join(figuresDir, f),
+        })),
+        tables: [],
+        summary: output.substring(0, 500),
+        diagnostics: [],
+    };
+}
+async function generateSimplifiedAnalysis(topic, method, datasetInfo, figuresDir, config) {
+    return `import matplotlib
+matplotlib.use('Agg')
+import pandas as pd
+import numpy as np
+import matplotlib.pyplot as plt
+import seaborn as sns
+import json
+import os
+from scipy import stats
+
+sns.set_theme(style='whitegrid', font_scale=1.2)
+figures_dir = "${figuresDir}"
+os.makedirs(figures_dir, exist_ok=True)
+
+# Load data
+df = pd.read_csv("${datasetInfo.finalDatasetPath}")
+print(f"Dataset: {df.shape[0]} rows, {df.shape[1]} columns")
+
+numeric_cols = df.select_dtypes(include=[np.number]).columns.tolist()
+date_cols = [c for c in df.columns if 'date' in c.lower() or 'time' in c.lower()]
+
+figures = []
+models = []
+tables = []
+diagnostics = []
+
+# 1. Descriptive statistics
+desc = df[numeric_cols].describe()
+print("\\nDescriptive Statistics:")
+print(desc)
+
+# 2. Correlation matrix
+if len(numeric_cols) >= 2:
+    fig, ax = plt.subplots(figsize=(12, 10))
+    corr = df[numeric_cols[:15]].corr()
+    sns.heatmap(corr, annot=True, fmt='.2f', cmap='RdBu_r', center=0, ax=ax)
+    ax.set_title('Correlation Matrix')
+    plt.tight_layout()
+    plt.savefig(os.path.join(figures_dir, 'correlation_matrix.png'), dpi=300, bbox_inches='tight')
+    plt.close()
+    figures.append({"filename": "correlation_matrix.png", "caption": "Correlation matrix of key variables"})
+
+# 3. Distribution plots
+for i, col in enumerate(numeric_cols[:6]):
+    fig, axes = plt.subplots(1, 2, figsize=(12, 5))
+    axes[0].hist(df[col].dropna(), bins=50, edgecolor='black', alpha=0.7)
+    axes[0].set_title(f'Distribution of {col}')
+    axes[0].set_xlabel(col)
+    axes[0].set_ylabel('Frequency')
+    stats.probplot(df[col].dropna(), plot=axes[1])
+    axes[1].set_title(f'Q-Q Plot: {col}')
+    plt.tight_layout()
+    fname = f'dist_{col.replace(" ", "_")[:20]}.png'
+    plt.savefig(os.path.join(figures_dir, fname), dpi=300, bbox_inches='tight')
+    plt.close()
+    figures.append({"filename": fname, "caption": f"Distribution and Q-Q plot of {col}"})
+
+# 4. Time series plot if date column exists
+if date_cols and len(numeric_cols) >= 1:
+    df_sorted = df.sort_values(date_cols[0])
+    fig, ax = plt.subplots(figsize=(14, 6))
+    for col in numeric_cols[:5]:
+        normalized = (df_sorted[col] - df_sorted[col].mean()) / df_sorted[col].std()
+        ax.plot(range(len(df_sorted)), normalized, label=col, alpha=0.8)
+    ax.set_title('Normalized Time Series')
+    ax.set_xlabel('Observation')
+    ax.set_ylabel('Standardized Value')
+    ax.legend()
+    plt.tight_layout()
+    plt.savefig(os.path.join(figures_dir, 'time_series.png'), dpi=300, bbox_inches='tight')
+    plt.close()
+    figures.append({"filename": "time_series.png", "caption": "Normalized time series of key variables"})
+
+# 5. OLS Regression (if enough numeric columns)
+if len(numeric_cols) >= 2:
+    try:
+        import statsmodels.api as sm
+        y = df[numeric_cols[0]].dropna()
+        X = df[numeric_cols[1:min(6, len(numeric_cols))]].loc[y.index].dropna()
+        y = y.loc[X.index]
+        X = sm.add_constant(X)
+
+        model = sm.OLS(y, X).fit(cov_type='HC3')
+        print("\\nOLS Results:")
+        print(model.summary())
+
+        coefficients = {k: float(v) for k, v in model.params.items()}
+        std_errors = {k: float(v) for k, v in model.bse.items()}
+        p_values = {k: float(v) for k, v in model.pvalues.items()}
+
+        models.append({
+            "name": "OLS with robust SE",
+            "type": "regression",
+            "coefficients": coefficients,
+            "standardErrors": std_errors,
+            "rSquared": float(model.rsquared),
+            "pValues": p_values,
+            "diagnostics": [f"R-squared: {model.rsquared:.4f}", f"F-statistic: {model.fvalue:.2f}", f"Observations: {model.nobs}"],
+            "significant": any(v < 0.05 for v in p_values.values() if v != p_values.get('const', 1))
+        })
+
+        diagnostics.append(f"R-squared: {model.rsquared:.4f}")
+        diagnostics.append(f"F-statistic: {model.fvalue:.2f} (p={model.f_pvalue:.4f})")
+        diagnostics.append(f"Durbin-Watson: {float(sm.stats.durbin_watson(model.resid)):.2f}")
+
+        # Residual plot
+        fig, axes = plt.subplots(1, 2, figsize=(14, 6))
+        axes[0].scatter(model.fittedvalues, model.resid, alpha=0.5)
+        axes[0].axhline(y=0, color='r', linestyle='--')
+        axes[0].set_xlabel('Fitted Values')
+        axes[0].set_ylabel('Residuals')
+        axes[0].set_title('Residuals vs Fitted')
+        axes[1].hist(model.resid, bins=40, edgecolor='black', alpha=0.7)
+        axes[1].set_title('Residual Distribution')
+        plt.tight_layout()
+        plt.savefig(os.path.join(figures_dir, 'ols_diagnostics.png'), dpi=300, bbox_inches='tight')
+        plt.close()
+        figures.append({"filename": "ols_diagnostics.png", "caption": "OLS diagnostic plots: residuals vs fitted and residual distribution"})
+    except Exception as e:
+        print(f"OLS failed: {e}")
+
+# 6. Scatter matrix
+if len(numeric_cols) >= 3:
+    cols_for_scatter = numeric_cols[:5]
+    fig = plt.figure(figsize=(14, 14))
+    pd.plotting.scatter_matrix(df[cols_for_scatter].dropna(), figsize=(14, 14), alpha=0.5)
+    plt.suptitle('Scatter Matrix', y=1.02)
+    plt.tight_layout()
+    plt.savefig(os.path.join(figures_dir, 'scatter_matrix.png'), dpi=300, bbox_inches='tight')
+    plt.close()
+    figures.append({"filename": "scatter_matrix.png", "caption": "Scatter matrix of key variables"})
+
+# 7. Box plots
+if len(numeric_cols) >= 2:
+    fig, ax = plt.subplots(figsize=(14, 6))
+    df[numeric_cols[:8]].boxplot(ax=ax)
+    ax.set_title('Box Plots of Key Variables')
+    plt.xticks(rotation=45)
+    plt.tight_layout()
+    plt.savefig(os.path.join(figures_dir, 'boxplots.png'), dpi=300, bbox_inches='tight')
+    plt.close()
+    figures.append({"filename": "boxplots.png", "caption": "Box plots of key variables"})
+
+# Output JSON summary
+result = {
+    "models": models,
+    "figures": figures,
+    "tables": tables,
+    "summary": f"Analysis of {len(df)} observations across {len(numeric_cols)} numeric variables. {len(models)} models estimated, {len(figures)} figures generated.",
+    "diagnostics": diagnostics
+}
+print("\\n" + json.dumps(result))
+`;
+}

package/dist/agents/gauss.js

@@ -0,0 +1,177 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runGauss = runGauss;
+const ora_1 = __importDefault(require("ora"));
+const llm_1 = require("../utils/llm");
+const academic_1 = require("../connectors/academic");
+const banner_1 = require("../cli/banner");
+async function runGauss(topic, config, logger) {
+    const spinner = (0, ora_1.default)({ text: 'Gauss: Searching academic literature...', indent: 2 }).start();
+    logger.info(`[GAUSS] Starting gap analysis for: ${topic}`);
+    spinner.text = 'Gauss: Planning search strategy...';
+    const queries = await generateSearchQueries(topic, config);
+    logger.info(`[GAUSS] Generated ${queries.length} search queries`);
+    spinner.text = 'Gauss: Searching OpenAlex, arXiv, CrossRef...';
+    let allPapers = [];
+    let allBibtex = '';
+    const allSourcesUsed = [];
+    const allSourcesFailed = [];
+    for (const query of queries.slice(0, 5)) {
+        try {
+            const result = await (0, academic_1.multiSourceSearch)(query, {
+                limit: 20,
+                sources: ['openalex', 'arxiv', 'crossref'],
+                serpApiKey: config.SERPAPI_API_KEY,
+            });
+            allPapers.push(...result.papers);
+            allSourcesUsed.push(...result.sourcesUsed);
+            allSourcesFailed.push(...result.sourcesFailed);
+        }
+        catch (err) {
+            logger.warn(`[GAUSS] Search failed for query: ${query}`);
+        }
+    }
+    const seen = new Set();
+    allPapers = allPapers.filter((p) => {
+        const key = p.doi || p.title.toLowerCase().substring(0, 60);
+        if (seen.has(key))
+            return false;
+        seen.add(key);
+        return true;
+    });
+    allPapers.sort((a, b) => b.citationCount - a.citationCount);
+    allPapers = allPapers.slice(0, 80);
+    allBibtex = allPapers.map((p) => p.bibtex).join('\n\n');
+    spinner.text = `Gauss: Found ${allPapers.length} papers. Expanding citation network...`;
+    logger.info(`[GAUSS] Found ${allPapers.length} unique papers`);
+    const topPapers = allPapers.filter((p) => p.doi).slice(0, 5);
+    for (const paper of topPapers) {
+        try {
+            const refs = await (0, academic_1.getOpenAlexReferences)(paper.doi, 10);
+            for (const ref of refs) {
+                const key = ref.doi || ref.title.toLowerCase().substring(0, 60);
+                if (!seen.has(key)) {
+                    seen.add(key);
+                    allPapers.push(ref);
+                }
+            }
+        }
+        catch { }
+    }
+    spinner.text = `Gauss: Analyzing ${allPapers.length} papers for gaps...`;
+    const papersContext = allPapers.slice(0, 50).map((p) => `- ${p.citeKey}: "${p.title}" (${p.year || 'n.d.'}) [${p.citationCount} citations] — ${p.abstract.substring(0, 200)}`).join('\n');
+    const gapAnalysis = await (0, llm_1.callLLM)(config, `You are Gauss, the literature gap finder agent of AutoScholar. You are an expert in identifying unexplored research opportunities in academic literature.
+
+Analyze the provided papers and identify research gaps. Focus on:
+1. Methods not yet applied to this domain
+2. Datasets not yet explored
+3. Temporal gaps (recent phenomena not yet studied)
+4. Contradictions between papers
+5. Shared limitations that could be addressed
+6. Cross-disciplinary opportunities
+
+Respond in JSON format with this exact structure:
+{
+  "gaps": [
+    {
+      "title": "Gap title",
+      "description": "Detailed description",
+      "evidence": ["paper1 says X", "paper2 contradicts"],
+      "novelty": 0.8,
+      "feasibility": 0.7,
+      "citationPotential": 0.9,
+      "overallScore": 0.8,
+      "gapType": "method|dataset|temporal|contradiction|limitation|cross_disciplinary",
+      "suggestedApproach": "How to address this gap",
+      "relevantPapers": ["citekey1", "citekey2"],
+      "validationStatus": "validated|partially_explored|uncertain"
+    }
+  ],
+  "suggestedTitle": "Suggested paper title",
+  "suggestedAbstract": "150-word abstract",
+  "suggestedContributions": ["Contribution 1", "Contribution 2", "Contribution 3"],
+  "literatureSynthesis": "3000+ char synthesis of the field",
+  "thematicClusters": [
+    { "theme": "Theme name", "papers": ["key1"], "keyFindings": "Summary" }
+  ],
+  "scientificLandscape": {
+    "dominantMethods": ["OLS", "GARCH"],
+    "commonDatasets": ["CRSP", "Compustat"],
+    "sharedLimitations": ["Short sample period"],
+    "futureDirections": ["High-frequency analysis"]
+  }
+}`, `Research topic: ${topic}\n\nPapers found (${allPapers.length} total, showing top 50):\n${papersContext}`, { maxTokens: 8192 });
+    spinner.stop();
+    const parsed = (0, llm_1.parseJsonResponse)(gapAnalysis);
+    if (!parsed) {
+        logger.error('[GAUSS] Failed to parse gap analysis response');
+        return {
+            success: false,
+            topic,
+            totalPapersAnalyzed: allPapers.length,
+            sourcesUsed: [...new Set(allSourcesUsed)],
+            sourcesFailed: [...new Set(allSourcesFailed)],
+            gaps: [],
+            recommendedGap: null,
+            suggestedTitle: topic,
+            suggestedAbstract: '',
+            suggestedContributions: [],
+            literatureSynthesis: '',
+            thematicClusters: [],
+            scientificLandscape: { dominantMethods: [], commonDatasets: [], sharedLimitations: [], futureDirections: [] },
+            bibtexBlock: allBibtex,
+            papers: allPapers,
+        };
+    }
+    const gaps = (parsed.gaps || []).sort((a, b) => b.overallScore - a.overallScore);
+    const result = {
+        success: true,
+        topic,
+        totalPapersAnalyzed: allPapers.length,
+        sourcesUsed: [...new Set(allSourcesUsed)],
+        sourcesFailed: [...new Set(allSourcesFailed)],
+        gaps,
+        recommendedGap: gaps[0] || null,
+        suggestedTitle: parsed.suggestedTitle || topic,
+        suggestedAbstract: parsed.suggestedAbstract || '',
+        suggestedContributions: parsed.suggestedContributions || [],
+        literatureSynthesis: parsed.literatureSynthesis || '',
+        thematicClusters: parsed.thematicClusters || [],
+        scientificLandscape: parsed.scientificLandscape || { dominantMethods: [], commonDatasets: [], sharedLimitations: [], futureDirections: [] },
+        bibtexBlock: allBibtex,
+        papers: allPapers,
+    };
+    (0, banner_1.printSuccess)(`Analyzed ${allPapers.length} papers from ${[...new Set(allSourcesUsed)].join(', ')}`);
+    (0, banner_1.printSuccess)(`Found ${gaps.length} research gaps`);
+    if (result.recommendedGap) {
+        (0, banner_1.printInfo)(`Recommended: ${result.recommendedGap.title} (score: ${result.recommendedGap.overallScore.toFixed(2)})`);
+    }
+    (0, banner_1.printSuccess)(`Suggested title: "${result.suggestedTitle}"`);
+    logger.info(`[GAUSS] Complete — ${gaps.length} gaps identified, ${allPapers.length} papers analyzed`);
+    return result;
+}
+async function generateSearchQueries(topic, config) {
+    const response = await (0, llm_1.callLLM)(config, `Generate 7 diverse academic search queries for the given research topic. Cover:
+1. Core theoretical angle
+2. Methodological angle
+3. Recent developments (2023-2025)
+4. Contradictions/debates
+5. Adjacent field connection
+6. Applied/empirical angle
+7. Measurement/data angle
+
+Respond as a JSON array of strings, nothing else.`, topic, { maxTokens: 1024 });
+    const parsed = (0, llm_1.parseJsonResponse)(response);
+    if (Array.isArray(parsed))
+        return parsed;
+    return [
+        topic,
+        `${topic} methodology`,
+        `${topic} recent 2024`,
+        `${topic} empirical evidence`,
+        `${topic} literature review`,
+    ];
+}