wtf-p 0.2.0 → 0.4.0

package/{commands → vendors/claude/commands}/wtfp/analyze-bib.md

@@ -43,60 +43,51 @@ BibTeX file: $ARGUMENTS (optional - auto-detects .bib files if not provided)
 find . -name "*.bib" -type f 2>/dev/null | grep -v node_modules | grep -v .git | head -10
 ```
 
-If multiple found, use AskUserQuestion:
-- header: "BibTeX"
-- question: "Which bibliography file should I analyze?"
-- options: [list found files] + "Analyze all"
+If multiple found, use AskUserQuestion.
+If none found, exit with error.
+</step>
 
-If none found:
-```
-No .bib file found.
+<step name="parse_entries">
+**Parse BibTeX Index:**
+
+Use the specialized indexer tool to get a structured JSON summary of the bibliography. This handles large files efficiently.
 
-Either:
-1. Add your .bib file to the project
-2. Specify path: /wtfp:analyze-bib path/to/refs.bib
+```bash
+# Index the bibliography (returns JSON)
+node ~/.claude/bin/bib-index.js index "$ARGUMENTS"
 ```
-Exit command.
+*(If $ARGUMENTS is empty, use the file found in previous step)*
 
 </step>
 
-<step name="parse_entries">
-**Parse all BibTeX entries:**
+<step name="impact_analysis">
+**Impact Analysis:**
 
-Extract from each entry:
-- Citation key
-- Type (@article, @inproceedings, @book, etc.)
-- Authors
-- Title
-- Year
-- Venue (journal/booktitle)
-- Abstract (if present)
-- Keywords (if present)
+Analyze citation metrics (citations, velocity, age) to identify seminal and rising papers.
 
-Build structured inventory of all references.
+```bash
+node ~/.claude/bin/analyze-impact.js "$ARGUMENTS"
+```
+
+Output sections:
+1. **Seminal Works** (>1000 citations)
+2. **Rising Stars** (High citation velocity)
+3. **Review Suggested** (Old, low impact)
 
 </step>
 
 <step name="temporal_analysis">
 **Temporal Analysis:**
 
-Categorize by publication year:
-- **Foundational** (10+ years old): Seminal works, established theory
-- **Established** (5-10 years): Mature approaches, proven methods
-- **Recent** (2-5 years): Current state of the art
-- **Cutting edge** (<2 years): Latest developments, concurrent work
+Analyze the JSON output from the parse_entries step.
 
-```markdown
-## Temporal Distribution
-
-| Era | Count | Examples |
-|-----|-------|----------|
-| Foundational (pre-2015) | [N] | [key1], [key2] |
-| Established (2015-2019) | [N] | [key3], [key4] |
-| Recent (2020-2023) | [N] | [key5], [key6] |
-| Cutting edge (2024+) | [N] | [key7], [key8] |
-```
+Categorize entries by the `year` field in the JSON:
+- **Foundational** (10+ years old)
+- **Established** (5-10 years)
+- **Recent** (2-5 years)
+- **Cutting edge** (<2 years)
 
+Produce the "Temporal Distribution" table based on these counts.
 </step>
 
 <step name="cluster_topics">
@@ -125,21 +116,16 @@ Analyze titles, abstracts, and keywords to cluster papers by theme:
 </step>
 
 <step name="identify_seminal">
-**Identify Seminal Works:**
+**Verify Seminal Works:**
 
-Flag likely seminal papers based on:
-- High citation count (if DOI available, could fetch)
-- Foundational publication year
-- Appears in prestigious venue
-- Authors are field leaders
-- Title suggests foundational contribution
+Review the "Seminal Works" list from the Impact Analysis step.
 
 ```markdown
-## Seminal Works (Must Cite)
+## Seminal Works (Verified High Impact)
 
-| Key | Title | Why Seminal |
-|-----|-------|-------------|
-| [key] | [title] | [reason: foundational method, influential framework, etc.] |
+| Key | Title | Citations | Why Seminal |
+|-----|-------|-----------|-------------|
+| [key] | [title] | [N] | [reason] |
 ```
 
 Use AskUserQuestion:
@@ -233,15 +219,18 @@ Write to `.planning/sources/REFS.md`:
 **Total entries:** [N]
 **Analysis date:** [date]
 
+## Impact Analysis
+[From impact_analysis step]
+- Seminal Works (>1000 citations)
+- Rising Stars (High Velocity)
+- Review Suggested (Low Impact/Old)
+
 ## Temporal Distribution
 [From temporal_analysis step]
 
 ## Topic Clusters
 [From cluster_topics step]
 
-## Seminal Works
-[From identify_seminal step]
-
 ## Citation Map by Section
 [From map_to_sections step]
 

package/{commands → vendors/claude/commands}/wtfp/check-refs.md

@@ -55,16 +55,18 @@ Create one or specify path: /wtfp:check-refs path/to/refs.bib
 </step>
 
 <step name="parse_bib">
-**Extract all BibTeX keys:**
+**Extract BibTeX Keys:**
+
+Use the deterministic indexer to get an accurate list of keys from the .bib file.
 
 ```bash
-grep -E "^@[a-zA-Z]+\{" *.bib | sed 's/.*{\([^,]*\),.*/\1/'
+node ~/.claude/bin/bib-index.js index "$ARGUMENTS"
 ```
+*(Use the file found/selected in step 1)*
 
-Build inventory:
+Build inventory from the JSON output:
 - Entry key
-- Entry type (@article, @inproceedings, etc.)
-- Required fields present/missing
+- Title
 - Year
 </step>
 
@@ -133,10 +135,10 @@ Use AskUserQuestion:
   - "Keep all" — Leave .bib unchanged
   - "Comment out" — Keep but mark as unused
 
-For missing entries, offer to:
-- Search for DOI/metadata (if WebFetch available)
-- Create skeleton entry for user to complete
-- Flag for manual resolution
+For missing entries, offer to find them:
+1. **Search:** Run `node ~/.claude/bin/citation-fetcher.js "title or author"` (uses Semantic Scholar + CrossRef) to find the correct BibTeX.
+2. **Create:** If found, append the new entry to the .bib file.
+3. **Flag:** If not found, flag for manual resolution.
 </step>
 
 <step name="apply_fixes">

package/vendors/claude/commands/wtfp/create-poster.md

@@ -0,0 +1,42 @@
+---
+name: wtfp:create-poster
+description: Full workflow for creating an academic poster from project content
+allowed-tools:
+  - Read
+  - Write
+  - Bash
+  - AskUserQuestion
+---
+
+<objective>
+Generate an academic poster based on the current project's PROJECT.md and findings.
+Uses the wtfp-marp skill to compile to HTML.
+</objective>
+
+<context>
+@~/.claude/write-the-f-paper/references/principles.md
+@~/.claude/write-the-f-paper/templates/posters/basic.md
+</context>
+
+<process>
+## Step 1: Content Synthesis
+- Read `.planning/PROJECT.md` and any drafted sections.
+- Identify key findings, methodology, and conclusion.
+
+## Step 2: User Interview
+AskUserQuestion to determine:
+- Poster title (default to project title)
+- Authors
+- Key visuals/charts needed
+- Target audience
+
+## Step 3: Markdown Generation
+- Create `poster.md` using Marp format.
+- Integrate synthesized content.
+
+## Step 4: Compilation
+- Use `wtfp-marp` skill: `npx @marp-team/marp-cli poster.md -o poster.html`
+
+## Step 5: Review
+- Present the generated poster.html path to the user.
+</process>

package/vendors/claude/commands/wtfp/create-slides.md

@@ -0,0 +1,41 @@
+---
+name: wtfp:create-slides
+description: Full workflow for creating presentation slides from project content
+allowed-tools:
+  - Read
+  - Write
+  - Bash
+  - AskUserQuestion
+---
+
+<objective>
+Generate presentation slides based on the current project's PROJECT.md and findings.
+Uses the wtfp-marp skill to compile to PDF.
+</objective>
+
+<context>
+@~/.claude/write-the-f-paper/references/principles.md
+@~/.claude/write-the-f-paper/templates/slides/
+</context>
+
+<process>
+## Step 1: Content Synthesis
+- Read `.planning/PROJECT.md` and any drafted sections.
+- Identify the core narrative and supporting claims.
+
+## Step 2: User Interview
+AskUserQuestion to determine:
+- Presentation duration/target number of slides
+- Specific focus areas
+- Audience background
+
+## Step 3: Markdown Generation
+- Create `slides.md` using Marp format.
+- Separate slides with `---`.
+
+## Step 4: Compilation
+- Use `wtfp-marp` skill: `npx @marp-team/marp-cli slides.md -o slides.pdf`
+
+## Step 5: Review
+- Present the generated slides.pdf path to the user.
+</process>

package/{commands → vendors/claude/commands}/wtfp/help.md

@@ -1,6 +1,7 @@
 ---
 name: wtfp:help
 description: Show available WTF-P commands and usage guide
+allowed-tools: []
 ---
 
 <objective>
@@ -14,6 +15,7 @@ Output ONLY the reference content below. Do NOT add:
 - Any commentary beyond the reference
 </objective>
 
+<process>
 <reference>
 # WTF-P Command Reference
 
@@ -365,3 +367,4 @@ Guide through contributing code via Pull Request.
 - Request features: `/wtfp:request-feature`
 - GitHub: https://github.com/akougkas/wtf-p
 </reference>
+</process>

package/{commands → vendors/claude/commands}/wtfp/new-paper.md

@@ -88,116 +88,77 @@ Exit command.
 
 </step>
 
-<step name="type">
+<step name="initial_batch">
 
-**Ask paper type:**
+**Gather Core Context (Batched):**
 
-Use AskUserQuestion:
-- header: "Paper Type"
-- question: "What type of document are you writing?"
+Use AskUserQuestion to collect the foundational pillars in one turn.
+
+- header: "Paper Foundations"
+- question: "To initialize the project, I need to understand 4 things. Answer what you can, and I'll infer or ask about the rest:\n\n1. **Type:** (Research paper, Grant, Thesis, etc.)\n2. **Venue:** (Target conference/journal, e.g., NeurIPS, CHI, Nature)\n3. **Core Argument:** (The one main thing you are proving/proposing)\n4. **Audience:** (Who is this for?)"
 - options:
-  - "Research paper" — Journal article or conference paper
-  - "Grant proposal" — Funding application (NSF, NIH, etc.)
-  - "Thesis chapter" — Dissertation or thesis section
-  - "Other" — Essay, report, or something else
+  - "I provided the details" — Continue with what I said
+  - "Guide me step-by-step" — I prefer individual questions
+
+**If "Guide me step-by-step":**
+Fall back to the sequential interview mode (ask Type, then Venue, then Argument).
 
-Store the document type for later structure decisions.
+**If "I provided the details":**
+Parse the response to extract: `document_type`, `target_venue`, `core_argument`, `target_audience`.
 
 </step>
 
 <step name="venue_template">
 
-**Select venue template (for research papers):**
+**Select venue template (if not inferred):**
 
-If document type is "Research paper", ask for venue template:
+If `document_type` or `target_venue` is ambiguous, ask specifically for the template:
 
 Use AskUserQuestion:
-- header: "Venue"
-- question: "What's your target venue or field?"
+- header: "Venue Structure"
+- question: "Based on your input, which structure fits best?"
 - options:
-  - "ACM CS" — Systems, databases, architecture (SIGMOD, OSDI, SOSP)
-  - "IEEE CS" — HPC, parallel systems, storage (SC, IPDPS, TPDS)
+  - "ACM CS" — Systems/Databases (SIGMOD, SOSP)
+  - "IEEE CS" — HPC/Systems (SC, IPDPS)
   - "ML/AI" — NeurIPS, ICML, ICLR style
-  - "Nature/Science" — Classic IMRaD for life sciences
-  - "Other" — Custom structure
+  - "Nature/Science" — Life Sciences IMRaD
+  - "Grant" — Funding Proposal
+  - "Thesis" — Dissertation Chapter
+  - "Other" — Custom
 
 **Load venue template:**
-
-Based on selection, read the corresponding venue template:
-- ACM CS → `~/.claude/write-the-f-paper/venues/acm-cs.yaml`
-- IEEE CS → `~/.claude/write-the-f-paper/venues/ieee-cs.yaml`
-- ML/AI → `~/.claude/write-the-f-paper/venues/arxiv-ml.yaml`
-- Nature/Science → `~/.claude/write-the-f-paper/venues/nature.yaml`
-- Other → Ask user to describe structure
-
-If document type is "Thesis chapter":
-- Load `~/.claude/write-the-f-paper/venues/thesis-chapter.yaml`
-
-Store the selected venue template for use in structure step.
+(Load corresponding YAML from `~/.claude/write-the-f-paper/venues/`)
 
 </step>
 
-<step name="question">
-
-**1. Open (FREEFORM — do NOT use AskUserQuestion):**
-
-Ask inline: "What is the core argument or contribution of your paper?"
-
-Wait for their freeform response. This gives you the context needed to ask intelligent follow-up questions.
-
-**2. Follow the thread (NOW use AskUserQuestion):**
+<step name="refine_argument">
 
-Based on their response, use AskUserQuestion with options that probe what they mentioned:
-- header: "[Topic they mentioned]"
-- question: "You mentioned [X] — how would you describe the key insight?"
-- options: 2-3 interpretations + "Something else"
+**Sharpen the Core:**
 
-**3. Target venue:**
+If `core_argument` was weak or missing in the batch, drill down now.
 
 Use AskUserQuestion:
-- header: "Venue"
-- question: "What's the target venue or format?"
-- options: Common venues for their field + "Undecided" + "Let me specify"
+- header: "Refine Core"
+- question: "Let's sharpen the core argument. If reviewers remember ONE thing, what is it?"
+- options:
+  - "The Method" — A new way of doing X
+  - "The Findings" — We discovered Y
+  - "The Theory" — A new perspective on Z
+  - "The System" — We built system Q
+  - "Write my own" — (User types input)
 
-**4. Sharpen the core:**
+</step>
 
-Use AskUserQuestion:
-- header: "Core"
-- question: "If reviewers remember one thing, what should it be?"
-- options: Key aspects they've mentioned + "The methodology" + "The findings" + "Something else"
+<step name="constraints_batch">
 
-**5. Find boundaries:**
+**Gather Constraints & Boundaries (Batched):**
 
 Use AskUserQuestion:
-- header: "Scope"
-- question: "What's explicitly NOT in this paper?"
-- options: Tempting tangents + "Nothing specific" + "Let me list them"
-
-**6. Constraints:**
-
-Use AskUserQuestion:
-- header: "Constraints"
-- question: "Any hard constraints?"
+- header: "Scope & Limits"
+- question: "Finally, define the box we are playing in:\n\n1. **Out of Scope:** What are we explicitly NOT doing?\n2. **Hard Constraints:** Page limits, deadlines, data restrictions?"
 - options:
-  - "Page/word limit" — Strict length requirements
-  - "Deadline" — Submission deadline pressure
-  - "Data limitations" — Working with specific dataset
-  - "None" — Flexible constraints
-  - "Multiple constraints" — Let me explain
-
-**7. Decision gate:**
-
-Use AskUserQuestion:
-- header: "Ready?"
-- question: "Ready to create PROJECT.md, or explore more?"
-- options (ALL THREE REQUIRED):
-  - "Create PROJECT.md" — Finalize and continue
-  - "Ask more questions" — I'll dig deeper
-  - "Let me add context" — You have more to share
-
-If "Ask more questions" → return to step 2.
-If "Let me add context" → receive input via their response → return to step 2.
-Loop until "Create PROJECT.md" selected.
+  - "Provided details" — Save and continue
+  - "No constraints" — Standard length, no specific exclusions
 
 </step>
 

package/{commands → vendors/claude/commands}/wtfp/research-gap.md

@@ -73,10 +73,9 @@ Use AskUserQuestion:
 Based on scope, investigate:
 
 **Key Citations:**
-- Identify foundational papers
-- Find recent high-impact work
-- Note methodological papers
-- Track disagreements/debates
+- **Foundational:** Use `node ~/.claude/bin/citation-fetcher.js "[topic]" --intent=seminal` to find high-impact papers.
+- **Recent:** Use `node ~/.claude/bin/citation-fetcher.js "[topic]" --intent=recent --year=2023-2026` to find state-of-the-art.
+- **Validation:** Use `node ~/.claude/bin/citation-fetcher.js "query"` to verify specific papers.
 
 **Standard Approaches:**
 - How do others structure similar sections?

package/vendors/claude/mcp/research-server/package.json

@@ -0,0 +1,13 @@
+{
+  "name": "wtf-p-research-server",
+  "version": "0.4.0",
+  "description": "MCP Server for ArXiv and Semantic Scholar citation retrieval",
+  "main": "src/index.js",
+  "bin": {
+    "wtfp-research": "src/index.js"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^0.6.0",
+    "node-fetch": "^2.7.0"
+  }
+}

package/vendors/claude/mcp/research-server/src/index.js

@@ -0,0 +1,133 @@
+#!/usr/bin/env node
+
+const { Server } = require("@modelcontextprotocol/sdk/server/index.js");
+const { StdioServerTransport } = require("@modelcontextprotocol/sdk/server/stdio.js");
+const { 
+  CallToolRequestSchema, 
+  ListToolsRequestSchema,
+  ErrorCode,
+  McpError 
+} = require("@modelcontextprotocol/sdk/types.js");
+const fetch = require("node-fetch");
+
+const SEMANTIC_SCHOLAR_API = "https://api.semanticscholar.org/graph/v1";
+
+class ResearchServer {
+  constructor() {
+    this.server = new Server(
+      {
+        name: "wtf-p-research",
+        version: "0.4.0",
+      },
+      {
+        capabilities: {
+          tools: {},
+        },
+      }
+    );
+
+    this.setupTools();
+    
+    this.server.onerror = (error) => console.error("[MCP Error]", error);
+    process.on("SIGINT", async () => {
+      await this.server.close();
+      process.exit(0);
+    });
+  }
+
+  setupTools() {
+    this.server.setRequestHandler(ListToolsRequestSchema, async () => ({
+      tools: [
+        {
+          name: "search_papers",
+          description: "Search for academic papers on Semantic Scholar",
+          inputSchema: {
+            type: "object",
+            properties: {
+              query: { type: "string", description: "Search query (title, authors, keywords)" },
+              limit: { type: "number", description: "Max results (default 5)", default: 5 },
+            },
+            required: ["query"],
+          },
+        },
+        {
+          name: "get_bibtex",
+          description: "Get BibTeX for a specific paper by its Semantic Scholar ID or DOI",
+          inputSchema: {
+            type: "object",
+            properties: {
+              paperId: { type: "string", description: "Semantic Scholar ID or DOI (prefix with 'DOI:')" },
+            },
+            required: ["paperId"],
+          },
+        },
+      ],
+    }));
+
+    this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
+      switch (request.params.name) {
+        case "search_papers":
+          return await this.handleSearch(request.params.arguments);
+        case "get_bibtex":
+          return await this.handleGetBibtex(request.params.arguments);
+        default:
+          throw new McpError(ErrorCode.MethodNotFound, `Unknown tool: ${request.params.name}`);
+      }
+    });
+  }
+
+  async handleSearch(args) {
+    const { query, limit = 5 } = args;
+    try {
+      const response = await fetch(
+        `${SEMANTIC_SCHOLAR_API}/paper/search?query=${encodeURIComponent(query)}&limit=${limit}&fields=title,authors,year,abstract,venue,externalIds`
+      );
+      if (!response.ok) throw new Error(`API error: ${response.statusText}`);
+      const data = await response.json();
+      
+      return {
+        content: [{ type: "text", text: JSON.stringify(data.data || [], null, 2) }],
+      };
+    } catch (error) {
+      return {
+        content: [{ type: "text", text: `Error searching papers: ${error.message}` }],
+        isError: true,
+      };
+    }
+  }
+
+  async handleGetBibtex(args) {
+    const { paperId } = args;
+    try {
+      // In a real implementation, we might need a separate service or to construct BibTeX from the metadata
+      // For this prototype, we'll fetch the fields needed to construct a valid BibTeX entry.
+      const response = await fetch(
+        `${SEMANTIC_SCHOLAR_API}/paper/${paperId}?fields=title,authors,year,venue,externalIds,citationStyles`
+      );
+      if (!response.ok) throw new Error(`API error: ${response.statusText}`);
+      const data = await response.json();
+      
+      const authors = (data.authors || []).map(a => a.name).join(' and ');
+      const bibtex = `@article{${data.externalIds?.DOI || data.paperId},\n  title={${data.title}},\n  author={${authors}},\n  journal={${data.venue || 'Unknown'}},\n  year={${data.year}}
+}`;
+
+      return {
+        content: [{ type: "text", text: bibtex }],
+      };
+    } catch (error) {
+      return {
+        content: [{ type: "text", text: `Error fetching BibTeX: ${error.message}` }],
+        isError: true,
+      };
+    }
+  }
+
+  async run() {
+    const transport = new StdioServerTransport();
+    await this.server.connect(transport);
+    console.error("Research MCP server running on stdio");
+  }
+}
+
+const server = new ResearchServer();
+server.run().catch(console.error);

package/vendors/claude/skills/wtfp/echarts/SKILL.md

@@ -0,0 +1,47 @@
+---
+name: wtfp-echarts
+description: Generate publication-quality charts using Apache ECharts
+allowed-tools:
+  - Bash
+  - Read
+  - Write
+---
+
+# ECharts Generator Skill
+
+Use this skill to create charts from data for papers, posters, or slides.
+
+## Usage
+
+Generate an HTML file with ECharts configuration.
+
+### Example Template
+```html
+<!DOCTYPE html>
+<html>
+<head>
+    <meta charset="utf-8">
+    <script src="https://cdn.jsdelivr.net/npm/echarts@5.4.3/dist/echarts.min.js"></script>
+</head>
+<body>
+    <div id="main" style="width: 800px;height:600px;"></div>
+    <script type="text/javascript">
+        var myChart = echarts.init(document.getElementById('main'));
+        var option = {
+            title: { text: 'ECharts Example' },
+            tooltip: {},
+            xAxis: { data: ["A", "B", "C", "D"] },
+            yAxis: {},
+            series: [{ name: 'Sales', type: 'bar', data: [5, 20, 36, 10] }]
+        };
+        myChart.setOption(option);
+    </script>
+</body>
+</html>
+```
+
+## Strategy
+1.  Receive data and chart requirements.
+2.  Generate ECharts configuration object.
+3.  Inject into HTML template.
+4.  User can open HTML in browser to view/export.