@gonzih/research-rabbit 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Maksim Soltan
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,330 @@
+# research-rabbit
+
+An MCP server that helps students do real academic research. It searches ArXiv, Semantic Scholar, OpenAlex, and PubMed simultaneously, analyzes the literature with Claude, finds research gaps, and builds argument scaffolds — all grounded in real papers with verifiable URLs.
+
+No hallucinated citations. No made-up abstracts. Real sources, real analysis.
+
+## Quick Start
+
+### Install and build
+
+```bash
+npm install
+npm run build
+```
+
+### Configure with Claude Desktop
+
+Add to your `claude_desktop_config.json`:
+
+```json
+{
+  "mcpServers": {
+    "research-rabbit": {
+      "command": "node",
+      "args": ["/path/to/research-rabbit/dist/index.js"],
+      "env": {
+        "ANTHROPIC_API_KEY": "your-api-key-here"
+      }
+    }
+  }
+}
+```
+
+### Configure with Cursor
+
+Add to your Cursor MCP settings:
+
+```json
+{
+  "research-rabbit": {
+    "command": "node",
+    "args": ["/path/to/research-rabbit/dist/index.js"],
+    "env": {
+      "ANTHROPIC_API_KEY": "your-api-key-here"
+    }
+  }
+}
+```
+
+### Run directly
+
+```bash
+ANTHROPIC_API_KEY=your-key node dist/index.js
+```
+
+## Tools Reference
+
+### `search_papers`
+
+Search multiple academic databases simultaneously and return real paper metadata.
+
+**Parameters:**
+- `query` (string, required): Search query. Be specific — include populations, methods, outcomes.
+- `sources` (array, optional): Which databases to search. Options: `"arxiv"`, `"semantic_scholar"`, `"openalex"`, `"pubmed"`. Default: all four.
+- `limit` (number, optional): Papers to return. Range: 1–25. Default: 10.
+- `yearFrom` (number, optional): Earliest publication year.
+
+**Example:**
+```json
+{
+  "query": "social media depression teenagers longitudinal",
+  "sources": ["semantic_scholar", "pubmed"],
+  "limit": 10,
+  "yearFrom": 2018
+}
+```
+
+**Returns:** Array of Paper objects with `id`, `source`, `title`, `authors`, `year`, `abstract`, `citationCount`, `doi`, `url`, `openAccessPdfUrl`.
+
+---
+
+### `summarize_paper`
+
+Generate a structured summary of a paper from its abstract using Claude. Identifies the main claim, methodology, key evidence, and limitations — and assesses how relevant it is to the student's topic.
+
+**Parameters:**
+- `paperId` (string): Paper ID from `search_papers` results.
+- `title` (string): Paper title.
+- `abstract` (string): Full abstract text.
+- `topic` (string): The student's research topic (used to assess relevance).
+
+**Example:**
+```json
+{
+  "paperId": "pubmed:38293847",
+  "title": "Instagram use and adolescent depression: a longitudinal study",
+  "abstract": "Background: ...",
+  "topic": "mental health effects of social media on teenagers"
+}
+```
+
+**Returns:** `PaperSummary` with `mainClaim`, `methodology`, `keyEvidence[]`, `limitations[]`, `relevanceToTopic`.
+
+---
+
+### `map_literature`
+
+Analyze a set of papers to produce a structured map of the field. Identifies what researchers agree on, where they disagree, methodological tensions, and how thinking has evolved over time.
+
+**Parameters:**
+- `papers` (array, required): 2–20 Paper objects from `search_papers`.
+- `topic` (string, required): The research topic.
+
+**Returns:** `LiteratureMap` with `consensus[]`, `debates[]`, `methodologicalTensions[]`, `temporalTrends[]`. Each entry cites specific papers using [1], [2] notation.
+
+---
+
+### `find_gaps`
+
+Identify what the literature is NOT studying — where a student's original contribution can live. Categorizes gaps by type and marks confidence levels.
+
+**Parameters:**
+- `papers` (array, required): 2–20 Paper objects.
+- `topic` (string, required): The research topic.
+
+**Returns:**
+- `gaps[]`: Each gap has `description`, `type` (population/temporal/methodological/geographic/theoretical/other), `confidence` (high/medium/low), and `rationale`.
+- `originalContributionAngles[]`: Specific suggestions for what a student could add.
+
+---
+
+### `build_argument`
+
+Build a structured argument scaffold for a research paper. Maps available evidence to supporting arguments, anticipates counterarguments with rebuttals, and identifies missing evidence the student still needs.
+
+**Parameters:**
+- `topic` (string): The research topic.
+- `thesis` (string): The student's thesis statement.
+- `papers` (array, required): 1–20 Paper objects to draw evidence from.
+
+**Returns:**
+- `argumentScaffold`: `thesisStatement`, `supportingArguments[]` (each with `claim`, `evidence[]`, `paperIds[]`), `counterarguments[]` (each with `claim`, `rebuttal`, `paperIds[]`), `suggestedStructure[]`.
+- `missingEvidence[]`: What the student still needs to find.
+
+---
+
+### `format_citation`
+
+Format a paper in APA, MLA, or Chicago style using real metadata. Only formats papers returned from `search_papers` — never invents citations.
+
+**Parameters:**
+- `paper`: A Paper object from `search_papers`.
+- `style`: `"apa"`, `"mla"`, or `"chicago"`.
+
+**Returns:** Formatted citation string.
+
+**Example output (APA):**
+```
+Twenge, J., Haidt, J. (2019). This is our chance to stop social media from harming teen girls' mental health. Semantic Scholar. https://www.semanticscholar.org/paper/abc123
+```
+
+---
+
+### `search_and_summarize`
+
+All-in-one research assistant. Searches all databases, summarizes the top papers, maps the literature, and finds gaps — in a single tool call. Best for getting oriented on a new topic quickly.
+
+**Parameters:**
+- `query` (string, required): Research topic or question.
+- `depth` (`"quick"` | `"thorough"`, optional): `"quick"` searches 5 papers; `"thorough"` searches 10 with full gap analysis. Default: `"quick"`.
+
+**Returns:** Combined object with `papers[]`, `summaries[]`, `literatureMap`, `gaps`.
+
+---
+
+## Research Methodology Primer
+
+### What is a literature review?
+
+A literature review is a systematic survey of what has already been written about your topic. It does three things:
+
+1. **Maps the terrain** — what has been studied, by whom, with what methods
+2. **Shows the state of knowledge** — what is settled, what is debated
+3. **Identifies the gap** — what hasn't been studied yet, where your work fits
+
+A strong literature review is not a list of summaries. It is a synthesis that builds a case for why your research question matters and hasn't been answered yet.
+
+### How to find research gaps
+
+A research gap is a question the literature hasn't answered. Gaps come in several types:
+
+- **Population gaps**: Studies have only examined one demographic group (e.g., only adults, only Americans)
+- **Temporal gaps**: The phenomenon hasn't been studied recently, or long-term effects are unknown
+- **Methodological gaps**: Most studies use surveys; no one has done qualitative interviews, or vice versa
+- **Geographic gaps**: Findings from Western countries may not apply elsewhere
+- **Theoretical gaps**: Existing frameworks don't explain a phenomenon well
+- **Interaction gaps**: Two variables have been studied separately but never together
+
+Use `find_gaps` to identify these automatically, then verify by checking whether the gap is actually present in the literature.
+
+### How to build a research argument
+
+A research argument has four parts:
+
+1. **Thesis**: Your central claim (what you are arguing is true)
+2. **Warrant**: Why the claim matters (why anyone should care)
+3. **Evidence**: Papers that support your claim
+4. **Counterargument**: The strongest objection to your thesis, and your response
+
+Use `build_argument` to generate a scaffold, then fill it in with your own analysis. The tool will tell you what evidence is missing so you know what to search for next.
+
+---
+
+## Example Workflow: Mental Health and Social Media
+
+### Step 1: Get oriented
+
+```
+search_and_summarize(
+  query="social media mental health adolescents depression anxiety",
+  depth="thorough"
+)
+```
+
+This returns 10 papers, summarizes each, maps the literature, and identifies gaps. You now know the main debates (correlational vs. causal evidence, passive vs. active use) and can see which populations are understudied.
+
+### Step 2: Go deeper on a specific angle
+
+The gap analysis suggests that "effects on boys vs. girls" is understudied. Search specifically:
+
+```
+search_papers(
+  query="social media depression gender differences adolescents boys girls",
+  sources=["pubmed", "semantic_scholar"],
+  limit=10,
+  yearFrom=2015
+)
+```
+
+### Step 3: Summarize key papers
+
+For each paper with a substantial abstract:
+
+```
+summarize_paper(
+  paperId="pubmed:38293847",
+  title="...",
+  abstract="...",
+  topic="gender differences in social media effects on adolescent mental health"
+)
+```
+
+### Step 4: Map the gender-specific literature
+
+```
+map_literature(
+  papers=[...the papers from Step 2...],
+  topic="gender differences in social media and adolescent mental health"
+)
+```
+
+### Step 5: Draft your thesis and build an argument
+
+```
+build_argument(
+  topic="social media and adolescent mental health",
+  thesis="Passive consumption of Instagram harms girls' self-esteem more than boys' due to appearance-related social comparison, while active social use affects both genders equally",
+  papers=[...all collected papers...]
+)
+```
+
+The output shows which papers support each sub-claim and which evidence is still missing (e.g., "experimental studies manipulating active vs. passive use by gender").
+
+### Step 6: Format citations for your reference list
+
+```
+format_citation(paper={...}, style="apa")
+```
+
+---
+
+## Responsible Use
+
+### What this tool guarantees
+- All papers are fetched from real academic APIs in real time
+- Every paper includes a verifiable URL
+- Gap confidence levels are explicit (high/medium/low)
+- Analysis is labeled as AI interpretation, not ground truth
+
+### What you should always do
+- Click the `url` of any paper you cite to verify it exists and says what the summary claims
+- For important arguments, read the full paper, not just the abstract
+- Cross-check citations against official style guides before final submission
+- Treat `confidence: "low"` gaps as hypotheses to investigate, not established facts
+
+### Academic integrity
+This tool helps you find and analyze real literature faster. It does not write your paper for you, and it never should. The synthesis, argument, and original analysis must be yours. Using AI to fabricate sources is academic dishonesty; using AI to find and understand real sources is good research practice.
+
+---
+
+## API Sources
+
+| Database | Coverage | Best for |
+|---|---|---|
+| ArXiv | CS, Math, Physics, Economics preprints | STEM, cutting-edge research |
+| Semantic Scholar | Cross-disciplinary, 200M+ papers | Citation counts, open access |
+| OpenAlex | Cross-disciplinary, 250M+ works | Social sciences, humanities |
+| PubMed | Biomedical and life sciences | Medicine, clinical research |
+
+All APIs are free and do not require authentication for basic usage. Semantic Scholar may rate-limit heavy usage; the server handles this gracefully by returning results from other sources.
+
+---
+
+## Development
+
+```bash
+# Install dependencies
+npm install
+
+# Run in development (no build step)
+npm run dev
+
+# Build
+npm run build
+
+# Run built version
+npm start
+```
+
+Requirements: Node.js 18+, `ANTHROPIC_API_KEY` environment variable.

package/SKILL.md

@@ -0,0 +1,109 @@
+# research-rabbit Skill Guide
+
+A guide to using research-rabbit effectively as an AI-assisted research workflow.
+
+## What This Skill Does
+
+research-rabbit turns your AI assistant into a real academic research partner. It connects to live academic databases (ArXiv, Semantic Scholar, OpenAlex, PubMed) and uses Claude to intelligently analyze the literature — no hallucinated citations, no made-up papers.
+
+## Core Workflow Patterns
+
+### Pattern 1: Quick Topic Exploration
+
+Use `search_and_summarize` with `depth: "quick"` when you want a fast overview of a topic. This runs all steps in sequence and returns papers, summaries, a literature map, and gap analysis in one shot.
+
+```
+search_and_summarize(query="CRISPR gene editing ethics", depth="quick")
+```
+
+### Pattern 2: Deep Literature Review
+
+For a thorough literature review, chain the tools:
+
+1. `search_papers` — retrieve papers from multiple sources
+2. `summarize_paper` — summarize each paper individually (good for diving deep into specific papers)
+3. `map_literature` — get the big picture of consensus and debates
+4. `find_gaps` — identify where your contribution can live
+5. `build_argument` — scaffold your thesis with real evidence
+6. `format_citation` — generate properly formatted citations
+
+### Pattern 3: Targeted Database Search
+
+When you know which database is most relevant to your field:
+
+- **STEM / Computer Science / Math**: use `sources: ["arxiv", "semantic_scholar"]`
+- **Life Sciences / Medicine**: use `sources: ["pubmed", "openalex"]`
+- **Social Sciences / Humanities**: use `sources: ["openalex", "semantic_scholar"]`
+- **Everything**: omit `sources` to search all four simultaneously
+
+### Pattern 4: Citation Management
+
+After running `search_papers`, pass individual paper objects to `format_citation` with your preferred style. This guarantees citations are grounded in real metadata.
+
+## Tips for Better Results
+
+**Query construction**: Be specific. "social media mental health teenagers depression" will outperform "social media effects". Include key terms, populations, and outcomes you care about.
+
+**Year filtering**: Use `yearFrom` to focus on recent literature (e.g., `yearFrom: 2020` for the last 5 years). Crucial for fast-moving fields.
+
+**Limit tuning**: Start with `limit: 10` (default). Increase to 20-25 when you need broad coverage. Decrease to 5 for speed.
+
+**Gap confidence**: When reading gap analysis output, prioritize `confidence: "high"` gaps — these are directly evidenced by the paper abstracts. Treat `confidence: "low"` gaps as hypotheses to investigate further.
+
+**Iterative refinement**: Run `search_papers` with different query phrasings and merge the results before running `map_literature`. This gives a richer picture than a single search.
+
+## Understanding the Output
+
+### Paper object
+Every paper returned includes:
+- `id`: unique identifier with source prefix (`arxiv:`, `ss:`, `openalex:`, `pubmed:`)
+- `source`: which database it came from
+- `url`: always a real, verifiable URL
+- `openAccessPdfUrl`: when available, a direct link to the full PDF
+
+### Literature Map
+- `consensus`: findings most papers agree on — your background facts
+- `debates`: active disagreements — your opportunity to take a side
+- `methodologicalTensions`: how different research methods produce different results — useful for methodology sections
+- `temporalTrends`: how the field has evolved — useful for introductions
+
+### Gap Analysis
+- `gaps`: what the literature is missing, categorized by type (population, temporal, methodological, geographic, theoretical)
+- `originalContributionAngles`: specific suggestions for where your work can add value
+
+### Argument Scaffold
+- `thesisStatement`: a refined version of your thesis
+- `supportingArguments`: each argument linked to specific papers and evidence
+- `counterarguments`: anticipated objections with paper-backed rebuttals
+- `suggestedStructure`: a proposed outline for your paper
+- `missingEvidence`: what you still need to find — your next search queries
+
+## Responsible Use
+
+- All sources are real papers from real APIs. Verify important claims by clicking the `url` links.
+- Abstracts are sometimes incomplete or misleading. For important arguments, read the full paper.
+- Gap analysis is Claude's interpretation of the literature, not ground truth. Use it as a starting point, not a conclusion.
+- Citation formatting is best-effort. Always verify against official style guides for final submissions.
+- PubMed and OpenAlex have usage policies. This tool respects their rate limits and terms of service.
+
+## Field-Specific Guidance
+
+### STEM / Engineering
+- ArXiv has preprints that may not be peer-reviewed. Check publication status.
+- Citation counts from Semantic Scholar are reliable for assessing paper impact.
+- Use `yearFrom` aggressively — 2-3 years is often sufficient for fast-moving fields.
+
+### Social Sciences
+- OpenAlex covers more social science journals than ArXiv.
+- Look for methodological debates (quantitative vs. qualitative) in the literature map.
+- Geographic gaps are common — consider whether findings from one country generalize.
+
+### Medicine / Life Sciences
+- PubMed is the authoritative source — include it always.
+- Abstract structure is often standardized (Background/Methods/Results/Conclusions) — the summarizer handles this well.
+- Clinical trial papers will have strong methodology sections worth examining.
+
+### Humanities
+- Coverage is thinner than in STEM. Supplement with manual library searches.
+- Use gap analysis for theoretical angles rather than empirical gaps.
+- Chicago citation style is standard in most humanities disciplines.

package/dist/analysis.d.ts

@@ -0,0 +1,12 @@
+import type { Paper, PaperSummary, LiteratureMap, Gap, ArgumentScaffold } from './types.js';
+export declare function summarizePaper(paperId: string, title: string, abstract: string, topic: string): Promise<PaperSummary>;
+export declare function mapLiterature(papers: Paper[], topic: string): Promise<LiteratureMap>;
+export declare function findGaps(papers: Paper[], topic: string): Promise<{
+    gaps: Gap[];
+    originalContributionAngles: string[];
+}>;
+export declare function buildArgument(topic: string, thesis: string, papers: Paper[]): Promise<{
+    argumentScaffold: ArgumentScaffold;
+    missingEvidence: string[];
+}>;
+//# sourceMappingURL=analysis.d.ts.map

package/dist/analysis.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"analysis.d.ts","sourceRoot":"","sources":["../src/analysis.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,KAAK,EAAE,YAAY,EAAE,aAAa,EAAE,GAAG,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAC;AAa5F,wBAAsB,cAAc,CAClC,OAAO,EAAE,MAAM,EACf,KAAK,EAAE,MAAM,EACb,QAAQ,EAAE,MAAM,EAChB,KAAK,EAAE,MAAM,GACZ,OAAO,CAAC,YAAY,CAAC,CAoDvB;AAED,wBAAsB,aAAa,CAAC,MAAM,EAAE,KAAK,EAAE,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,aAAa,CAAC,CA6C1F;AAED,wBAAsB,QAAQ,CAAC,MAAM,EAAE,KAAK,EAAE,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC;IAAE,IAAI,EAAE,GAAG,EAAE,CAAC;IAAC,0BAA0B,EAAE,MAAM,EAAE,CAAA;CAAE,CAAC,CAmD7H;AAED,wBAAsB,aAAa,CACjC,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,KAAK,EAAE,GACd,OAAO,CAAC;IAAE,gBAAgB,EAAE,gBAAgB,CAAC;IAAC,eAAe,EAAE,MAAM,EAAE,CAAA;CAAE,CAAC,CA8D5E"}

package/dist/analysis.js

@@ -0,0 +1,217 @@
+import Anthropic from '@anthropic-ai/sdk';
+const client = new Anthropic();
+function papersToText(papers) {
+    return papers.map((p, i) => `[${i + 1}] "${p.title}" (${p.year}) by ${p.authors.slice(0, 3).join(', ')}${p.authors.length > 3 ? ' et al.' : ''}
+ID: ${p.id}
+Abstract: ${p.abstract.substring(0, 500)}${p.abstract.length > 500 ? '...' : ''}
+Citations: ${p.citationCount ?? 'unknown'}`).join('\n\n');
+}
+export async function summarizePaper(paperId, title, abstract, topic) {
+    if (abstract.trim().length < 50) {
+        return {
+            paperId,
+            title,
+            mainClaim: 'Abstract too short to summarize',
+            methodology: 'Unknown',
+            keyEvidence: [],
+            limitations: [],
+            relevanceToTopic: 'Could not assess relevance — abstract is too brief',
+        };
+    }
+    const response = await client.messages.create({
+        model: 'claude-opus-4-6',
+        max_tokens: 1024,
+        messages: [{
+                role: 'user',
+                content: `Analyze this academic paper abstract for a student researching: "${topic}"
+
+Title: ${title}
+Abstract: ${abstract}
+
+Respond with ONLY a JSON object (no markdown, no explanation) in this exact format:
+{
+  "mainClaim": "the paper's central finding or argument in one sentence",
+  "methodology": "the research method used (e.g., randomized controlled trial, meta-analysis, survey, etc.)",
+  "keyEvidence": ["evidence point 1", "evidence point 2"],
+  "limitations": ["limitation 1", "limitation 2"],
+  "relevanceToTopic": "how this paper relates to the student's topic in 1-2 sentences"
+}`,
+            }],
+    });
+    const text = response.content.find(b => b.type === 'text')?.text ?? '';
+    try {
+        const jsonMatch = text.match(/\{[\s\S]*\}/);
+        if (!jsonMatch)
+            throw new Error('No JSON found');
+        const parsed = JSON.parse(jsonMatch[0]);
+        return { paperId, title, ...parsed };
+    }
+    catch {
+        return {
+            paperId,
+            title,
+            mainClaim: text.substring(0, 200),
+            methodology: 'Could not parse',
+            keyEvidence: [],
+            limitations: [],
+            relevanceToTopic: 'Analysis failed — see raw text',
+        };
+    }
+}
+export async function mapLiterature(papers, topic) {
+    if (papers.length === 0) {
+        return { consensus: [], debates: [], methodologicalTensions: [], temporalTrends: [] };
+    }
+    const papersText = papersToText(papers);
+    const response = await client.messages.create({
+        model: 'claude-opus-4-6',
+        max_tokens: 2048,
+        messages: [{
+                role: 'user',
+                content: `You are helping a student map the academic literature on: "${topic}"
+
+Here are ${papers.length} papers from the literature:
+
+${papersText}
+
+Based ONLY on these papers (do not invent findings not present in the abstracts), identify:
+1. Areas of CONSENSUS — what do most papers agree on?
+2. Active DEBATES — where do papers disagree or conflict?
+3. METHODOLOGICAL TENSIONS — conflicts between research approaches (e.g., experimental vs. observational)?
+4. TEMPORAL TRENDS — how has thinking evolved over time?
+
+Respond with ONLY a JSON object:
+{
+  "consensus": ["finding 1 with paper reference", "finding 2"],
+  "debates": ["debate 1 with conflicting evidence", "debate 2"],
+  "methodologicalTensions": ["tension 1", "tension 2"],
+  "temporalTrends": ["trend 1", "trend 2"]
+}
+
+Be specific and cite paper numbers like [1], [2]. If insufficient data, say so briefly.`,
+            }],
+    });
+    const text = response.content.find(b => b.type === 'text')?.text ?? '';
+    try {
+        const jsonMatch = text.match(/\{[\s\S]*\}/);
+        if (!jsonMatch)
+            throw new Error('No JSON found');
+        return JSON.parse(jsonMatch[0]);
+    }
+    catch {
+        return { consensus: [text], debates: [], methodologicalTensions: [], temporalTrends: [] };
+    }
+}
+export async function findGaps(papers, topic) {
+    if (papers.length === 0) {
+        return { gaps: [], originalContributionAngles: [] };
+    }
+    const papersText = papersToText(papers);
+    const response = await client.messages.create({
+        model: 'claude-opus-4-6',
+        max_tokens: 2048,
+        messages: [{
+                role: 'user',
+                content: `You are helping a student find ORIGINAL RESEARCH ANGLES for a paper on: "${topic}"
+
+Here are ${papers.length} papers from the literature:
+
+${papersText}
+
+Based on what these papers DO and DON'T cover, identify:
+1. Genuine GAPS in the literature (populations unstudied, time periods missing, methods not tried, etc.)
+2. Angles for ORIGINAL STUDENT CONTRIBUTION (what could a student add that isn't already covered?)
+
+IMPORTANT: Mark speculative gaps with confidence "low". Only mark "high" confidence for gaps clearly evident from the abstracts.
+
+Respond with ONLY a JSON object:
+{
+  "gaps": [
+    {
+      "description": "clear description of what's missing",
+      "type": "population|temporal|methodological|geographic|theoretical|other",
+      "confidence": "high|medium|low",
+      "rationale": "why this is a gap based on the papers reviewed"
+    }
+  ],
+  "originalContributionAngles": [
+    "specific angle a student could take",
+    "another angle"
+  ]
+}`,
+            }],
+    });
+    const text = response.content.find(b => b.type === 'text')?.text ?? '';
+    try {
+        const jsonMatch = text.match(/\{[\s\S]*\}/);
+        if (!jsonMatch)
+            throw new Error('No JSON found');
+        return JSON.parse(jsonMatch[0]);
+    }
+    catch {
+        return { gaps: [{ description: text, type: 'other', confidence: 'low', rationale: 'Parse error' }], originalContributionAngles: [] };
+    }
+}
+export async function buildArgument(topic, thesis, papers) {
+    const papersText = papersToText(papers);
+    const response = await client.messages.create({
+        model: 'claude-opus-4-6',
+        max_tokens: 3000,
+        messages: [{
+                role: 'user',
+                content: `You are helping a student build a research argument for their paper.
+
+Topic: "${topic}"
+Student's Thesis: "${thesis}"
+
+Available papers:
+${papersText}
+
+Create a structured argument scaffold using ONLY the papers provided. Do not invent citations.
+
+Respond with ONLY a JSON object:
+{
+  "argumentScaffold": {
+    "thesisStatement": "refined version of the student's thesis",
+    "supportingArguments": [
+      {
+        "claim": "supporting argument 1",
+        "evidence": ["specific evidence from paper X", "evidence from paper Y"],
+        "paperIds": ["arxiv:...", "ss:..."]
+      }
+    ],
+    "counterarguments": [
+      {
+        "claim": "likely counterargument",
+        "rebuttal": "how to respond using the literature",
+        "paperIds": ["paper id that supports rebuttal"]
+      }
+    ],
+    "suggestedStructure": ["Introduction: ...", "Section 2: ...", "Conclusion: ..."]
+  },
+  "missingEvidence": [
+    "type of evidence still needed that wasn't found in the provided papers"
+  ]
+}`,
+            }],
+    });
+    const text = response.content.find(b => b.type === 'text')?.text ?? '';
+    try {
+        const jsonMatch = text.match(/\{[\s\S]*\}/);
+        if (!jsonMatch)
+            throw new Error('No JSON found');
+        return JSON.parse(jsonMatch[0]);
+    }
+    catch {
+        return {
+            argumentScaffold: {
+                thesisStatement: thesis,
+                supportingArguments: [],
+                counterarguments: [],
+                suggestedStructure: ['Could not generate structure'],
+            },
+            missingEvidence: ['Analysis failed'],
+        };
+    }
+}
+//# sourceMappingURL=analysis.js.map