wtf-p 0.3.0 → 0.4.0

package/README.md

@@ -213,6 +213,24 @@ The mapping phase analyzes:
 
 ---
 
+## Citation Expert (v0.4.0)
+
+WTF-P includes a specialized tiered pipeline for bibliography management.
+
+```bash
+/wtfp:analyze-bib      # Deep analysis of impact (seminal vs rising)
+/wtfp:research-gap     # Intent-aware search (seminal/recent)
+/wtfp:check-refs       # Auto-suggest missing citations
+```
+
+Capabilities:
+- **Tiered Search:** Integrated Semantic Scholar, SerpAPI (Google Scholar), and CrossRef.
+- **Impact Ranking:** Automatically scores papers by citations, velocity, and venue prestige.
+- **Deduplication:** universal anchoring via DOI and Scholar Cluster IDs.
+- **Provenance:** Entries track their metadata source and verification status.
+
+---
+
 ## Command Reference
 
 ### Setup

package/bin/commands/install-logic.js

@@ -187,16 +187,12 @@ async function install(isGlobal, isUpdate, options, pkg) {
   vendorConfig.components.forEach(component => {
     // Check --only filters
     if (onlyInstall !== 'all') {
-      // Map 'workflows' flag to 'workflows' component ID
-      // Map 'commands' flag to 'commands' component ID
-      // Map 'skills' flag to 'skills' component ID
-      if (onlyInstall !== component.id) {
-         // Special case: 'commands' usually implies 'skills' too in legacy logic
-         if (onlyInstall === 'commands' && component.id === 'skills') {
-           // Allow
-         } else {
-           return;
-         }
+      const allowedIds = [onlyInstall];
+      // Legacy mapping: 'commands' includes 'skills'
+      if (onlyInstall === 'commands') allowedIds.push('skills');
+      
+      if (!allowedIds.includes(component.id)) {
+        return;
       }
     }
     

package/bin/lib/analyze-impact.js

@@ -0,0 +1,105 @@
+const fs = require('fs');
+const s2 = require('./semantic-scholar');
+const ranker = require('./citation-ranker');
+const bibIndex = require('./bib-index'); // Assuming this exists or I need to use the one in bin/lib if available
+
+// Check if bib-index exists in bin/lib or I need to implement basic parsing
+// The command says `node ~/.claude/bin/bib-index.js`. 
+// In this project structure, it is likely `bin/lib/bib-index.js`.
+
+const BIB_INDEX_PATH = './bib-index.js';
+
+/**
+ * Impact Analyzer
+ * 
+ * Analyzes a BibTeX file or JSON index:
+ * 1. Fetches metrics for each paper (via S2)
+ * 2. Categorizes them (Seminal, Rising, Outdated)
+ * 3. Returns summary
+ */
+
+async function analyze(filePath) {
+  // 1. Index/Parse
+  let entries = [];
+  try {
+    // We'll require bib-index locally if possible
+    const indexer = require(BIB_INDEX_PATH);
+    const json = indexer.index(fs.readFileSync(filePath, 'utf8'));
+    entries = JSON.parse(json);
+  } catch (e) {
+    // Fallback: simple regex parsing if bib-index lib isn't easily require-able
+    console.error("Could not use bib-index, falling back to simple parse", e);
+    const content = fs.readFileSync(filePath, 'utf8');
+    const regex = /@\w+\s*{\s*([^,]+),[\s\S]*?title\s*=\s*[{"'](.+?)[}"'][\s\S]*?year\s*=\s*[{"'](\d{4})[}"']/gi;
+    let match;
+    while ((match = regex.exec(content)) !== null) {
+      entries.push({ key: match[1], title: match[2], year: parseInt(match[3]) });
+    }
+  }
+
+  const results = {
+    seminal: [], // > 1000 citations
+    rising: [],  // Velocity > 50/mo, < 1000 total
+    outdated: [], // > 10 years, < 50 citations
+    unknown: []
+  };
+
+  // Process in batches to avoid rate limits
+  const BATCH_SIZE = 5;
+  for (let i = 0; i < entries.length; i += BATCH_SIZE) {
+    const batch = entries.slice(i, i + BATCH_SIZE);
+    await Promise.all(batch.map(async (entry) => {
+      try {
+        // Search by title to get metrics (most reliable if DOI missing)
+        // Ideally we'd use DOI if we parsed it.
+        const papers = await s2.search(entry.title, { limit: 1 });
+        if (papers && papers.length > 0) {
+          const p = papers[0];
+          const velocity = ranker.calculateVelocity(p.citationCount, p.year);
+          const age = new Date().getFullYear() - (p.year || new Date().getFullYear());
+          
+          const enriched = { 
+            key: entry.key, 
+            title: p.title, 
+            year: p.year, 
+            citations: p.citationCount, 
+            velocity: velocity.toFixed(1) 
+          };
+
+          if (p.citationCount > 1000) {
+            results.seminal.push(enriched);
+          } else if (velocity > 10 && p.citationCount < 1000) { // Threshold adjusted: 50/mo is very high. 10/mo is solid.
+            results.rising.push(enriched);
+          } else if (age > 15 && p.citationCount < 50) {
+             results.outdated.push({ ...enriched, concern: `${age} years old, low citations` });
+          } else {
+            results.unknown.push(enriched);
+          }
+        } else {
+            results.unknown.push({ key: entry.key, title: entry.title, error: "Not found" });
+        }
+      } catch (e) {
+        results.unknown.push({ key: entry.key, title: entry.title, error: e.message });
+      }
+    }));
+    // Small delay between batches
+    await new Promise(r => setTimeout(r, 1000));
+  }
+  
+  // Sort
+  results.seminal.sort((a,b) => b.citations - a.citations);
+  results.rising.sort((a,b) => b.velocity - a.velocity);
+  
+  return results;
+}
+
+if (require.main === module) {
+  const file = process.argv[2];
+  if (!file) {
+    console.error("Usage: node analyze-impact.js <bibfile>");
+    process.exit(1);
+  }
+  analyze(file).then(r => console.log(JSON.stringify(r, null, 2)));
+}
+
+module.exports = { analyze };

package/bin/lib/bib-format.js

@@ -0,0 +1,161 @@
+const fs = require('fs');
+
+/**
+ * WTF-P BibTeX Formatter
+ * Standardizes BibTeX entries to the project's strict template.
+ * Handles missing fields and assigns provenance metadata.
+ */
+
+// --- Parsing Logic ---
+
+function parseField(text, field) {
+  // Regex to find field="value" or field={value}
+  const regex = new RegExp(`\\b${field}\\s*=\\s*[{"']([\\s\\S]*?)[}"']\\s*[,}]`, 'i');
+  const match = text.match(regex);
+  return match ? match[1].trim() : null;
+}
+
+function parseEntryType(text) {
+  const match = text.match(/@(\w+)\s*{/);
+  return match ? match[1].toLowerCase() : 'misc';
+}
+
+function parseKey(text) {
+  const match = text.match(/@\w+\s*{\s*([^,]+),/);
+  return match ? match[1].trim() : 'unknown_key';
+}
+
+function parse(rawEntry) {
+  const entryType = parseEntryType(rawEntry);
+  const key = parseKey(rawEntry);
+
+  return {
+    key,
+    entryType,
+    author: parseField(rawEntry, 'author'),
+    title: parseField(rawEntry, 'title'),
+    booktitle: parseField(rawEntry, 'booktitle') || parseField(rawEntry, 'journal'),
+    year: parseField(rawEntry, 'year'),
+    month: parseField(rawEntry, 'month'),
+    abstract: parseField(rawEntry, 'abstract'),
+    publisher: parseField(rawEntry, 'publisher'),
+    volume: parseField(rawEntry, 'volume'),
+    number: parseField(rawEntry, 'number'),
+    pages: parseField(rawEntry, 'pages'),
+    doi: parseField(rawEntry, 'doi'),
+    url: parseField(rawEntry, 'url'),
+    keywords: parseField(rawEntry, 'keywords'),
+    abbr: parseField(rawEntry, 'abbr'),
+    bibtex_show: parseField(rawEntry, 'bibtex_show'),
+    selected: parseField(rawEntry, 'selected'),
+    projects: parseField(rawEntry, 'projects')
+  };
+}
+
+// --- Formatting Logic ---
+
+function format(data, provenance = {}) {
+  // Determine Status
+  let status = provenance.wtfp_status || 'official';
+  const missingFields = [];
+
+  if (!data.doi) {
+    status = 'incomplete';
+    missingFields.push('doi');
+  }
+  if (!data.author || data.author === '{MISSING_AUTHOR}') {
+    status = 'incomplete';
+    missingFields.push('author');
+  }
+  if (!data.booktitle || data.booktitle === '{MISSING_VENUE}') {
+     missingFields.push('venue');
+  }
+  if (!data.abstract) {
+    if (status !== 'incomplete') status = 'partial'; 
+    missingFields.push('abstract');
+  }
+
+  // Use provided provenance or defaults
+  const wtfp_source = provenance.wtfp_source || '';
+  const wtfp_citations = provenance.wtfp_citations || '';
+  const wtfp_velocity = provenance.wtfp_velocity || '';
+  const wtfp_s2_id = provenance.wtfp_s2_id || '';
+  const wtfp_scholar_id = provenance.wtfp_scholar_id || '';
+  const wtfp_fetched = provenance.wtfp_fetched || new Date().toISOString().split('T')[0];
+
+  const entryType = data.entryType === 'inproceedings' ? 'conference' : (data.entryType === 'article' ? 'journal' : data.entryType || 'misc');
+  
+  // Clean fields
+  const clean = (val, fallback = "") => val || fallback;
+
+  return `@${entryType}{${data.key || 'unknown'},
+  abbr="${clean(data.abbr)}",
+  entry_type="${entryType}",
+  author="${clean(data.author, "{MISSING_AUTHOR}")}",
+  abstract="${clean(data.abstract)}",
+  booktitle="${clean(data.booktitle, "{MISSING_VENUE}")}",
+  title="${clean(data.title, "{MISSING_TITLE}")}",
+  year="${clean(data.year, "{????}")}",
+  month="${clean(data.month)}",
+  publisher="${clean(data.publisher)}",
+  volume="${clean(data.volume)}",
+  number="${clean(data.number)}",
+  pages="${clean(data.pages)}",
+  keywords="${clean(data.keywords)}",
+  doi="${clean(data.doi)}",
+  url="${clean(data.url, data.doi ? `https://doi.org/${data.doi}` : "")}",
+  html="${clean(data.html, data.doi ? `https://doi.org/${data.doi}` : "")}",
+  pdf="${clean(data.pdf, "paper.pdf")}",
+  google_scholar_id="${clean(data.google_scholar_id)}",
+  additional_info="${clean(data.additional_info)}",
+  bibtex_show="${clean(data.bibtex_show, "true")}",
+  selected="${clean(data.selected, "false")}",
+  projects="${clean(data.projects)}",
+  wtfp_status="${status}",
+  wtfp_source="${wtfp_source}",
+  wtfp_citations="${wtfp_citations}",
+  wtfp_velocity="${wtfp_velocity}",
+  wtfp_s2_id="${wtfp_s2_id}",
+  wtfp_scholar_id="${wtfp_scholar_id}",
+  wtfp_fetched="${wtfp_fetched}",
+  wtfp_missing="${missingFields.join(',')}"
+}`;
+}
+
+// --- CLI Handling ---
+
+if (require.main === module) {
+  const MODE = process.argv[2];
+  const INPUT = process.argv[3];
+  const KEY_ARG = process.argv[4];
+
+  if (!MODE) {
+    console.error('Usage: node bib-format.js <raw_string|--file> <content|filepath> [key]');
+    process.exit(1);
+  }
+
+  let rawEntry = '';
+
+  if (MODE === '--file') {
+    if (!fs.existsSync(INPUT)) {
+      console.error(`File not found: ${INPUT}`);
+      process.exit(1);
+    }
+    const content = fs.readFileSync(INPUT, 'utf8');
+    const regex = new RegExp(`@\w+\s*{\s*${KEY_ARG}\s*,[\s\S]*?\n}`, 'm');
+    const match = content.match(regex);
+    if (match) {
+      rawEntry = match[0];
+    } else {
+      console.error(`Key ${KEY_ARG} not found in ${INPUT}`);
+      process.exit(1);
+    }
+  } else {
+    rawEntry = INPUT;
+  }
+
+  const parsed = parse(rawEntry);
+  console.log(format(parsed));
+}
+
+module.exports = { parse, format };

package/bin/lib/bib-index.js

@@ -0,0 +1,104 @@
+const fs = require('fs');
+
+/**
+ * WTF-P Bibliography Indexer
+ * Indexes and retrieves BibTeX entries without loading the entire file into context.
+ */
+
+const ENTRY_REGEX = /@(\w+)\s*\{\s*([^,]+),([^@]*)\}/g;
+
+function parseEntries(text) {
+  const entries = [];
+  let match;
+  // Reset regex index just in case
+  ENTRY_REGEX.lastIndex = 0;
+  
+  while ((match = ENTRY_REGEX.exec(text)) !== null) {
+    const fullText = match[0];
+    const type = match[1];
+    const key = match[2].trim();
+    const body = match[3];
+    
+    // Extract title specifically for indexing
+    const titleMatch = body.match(/title\s*=\s*[{"'](.+?)[}"']/i);
+    const title = titleMatch ? titleMatch[1] : 'Unknown Title';
+    
+    // Extract year
+    const yearMatch = body.match(/year\s*=\s*[{"']?(\d+)[}"']?/i);
+    const year = yearMatch ? yearMatch[1] : '????';
+
+    entries.push({ key, type, title, year, fullText: `@${type}{${key},${body}}` });
+  }
+  return entries;
+}
+
+function index(content) {
+  const entries = parseEntries(content);
+  return JSON.stringify(entries.map(e => ({ key: e.key, title: e.title, year: e.year })), null, 2);
+}
+
+function getEntry(content, key) {
+  const entries = parseEntries(content);
+  const entry = entries.find(e => e.key === key);
+  return entry ? entry.fullText : null;
+}
+
+function search(content, query) {
+  const entries = parseEntries(content);
+  const q = query.toLowerCase();
+  const results = entries.filter(e => 
+    e.title.toLowerCase().includes(q) || 
+    e.key.toLowerCase().includes(q) ||
+    e.fullText.toLowerCase().includes(q)
+  );
+  return JSON.stringify(results.map(e => ({ key: e.key, title: e.title, year: e.year })), null, 2);
+}
+
+// --- CLI Handling ---
+
+if (require.main === module) {
+  const COMMAND = process.argv[2];
+  const BIB_FILE = process.argv[3];
+  const ARG = process.argv[4];
+
+  if (!COMMAND || !BIB_FILE) {
+    console.error('Usage: node bib-index.js <command> <bib_file> [arg]');
+    process.exit(1);
+  }
+
+  if (!fs.existsSync(BIB_FILE)) {
+    console.error(`Error: Bibliography file not found: ${BIB_FILE}`);
+    process.exit(1);
+  }
+
+  const content = fs.readFileSync(BIB_FILE, 'utf8');
+
+  if (COMMAND === 'index') {
+    console.log(index(content));
+  } 
+  else if (COMMAND === 'get') {
+    if (!ARG) {
+      console.error('Error: Missing citation key');
+      process.exit(1);
+    }
+    const result = getEntry(content, ARG);
+    if (result) console.log(result);
+    else {
+      console.error(`Error: Entry '${ARG}' not found.`);
+      process.exit(1);
+    }
+  }
+  else if (COMMAND === 'search') {
+    if (!ARG) {
+      console.error('Error: Missing search query');
+      process.exit(1);
+    }
+    console.log(search(content, ARG));
+  }
+  else {
+    console.error(`Unknown command: ${COMMAND}`);
+    process.exit(1);
+  }
+}
+
+module.exports = { index, getEntry, search, parseEntries };