wtf-p 0.3.0 → 0.5.0

package/bin/lib/manifest.js

@@ -26,6 +26,24 @@ const MANIFEST = {
         dest: 'skills/wtfp',
         type: 'dir'
       },
+      {
+        id: 'agents',
+        src: path.join(ROOT, 'vendors', 'claude', 'agents', 'wtfp'),
+        dest: 'agents/wtfp',
+        type: 'dir'
+      },
+      {
+        id: 'mcp',
+        src: path.join(ROOT, 'vendors', 'claude', 'mcp'),
+        dest: 'mcp',
+        type: 'dir'
+      },
+      {
+        id: 'scripts',
+        src: path.join(ROOT, 'bin', 'lib'),
+        dest: 'bin',
+        type: 'dir'
+      },
       {
         id: 'plugin',
         src: path.join(ROOT, 'vendors', 'claude', '.claude-plugin'),
@@ -34,8 +52,68 @@ const MANIFEST = {
       }
     ]
   },
-  // Future:
-  // gemini: { ... }
+  gemini: {
+    name: 'Gemini CLI',
+    configDirEnv: 'GEMINI_CONFIG_DIR',
+    defaultDir: '.config/gemini',
+    components: [
+      {
+        id: 'workflows',
+        src: path.join(ROOT, 'core', 'write-the-f-paper'),
+        dest: 'write-the-f-paper',
+        type: 'dir'
+      },
+      {
+        id: 'commands',
+        src: path.join(ROOT, 'vendors', 'gemini', 'commands', 'wtfp'),
+        dest: 'commands/wtfp',
+        type: 'dir'
+      },
+      {
+        id: 'agents',
+        src: path.join(ROOT, 'vendors', 'gemini', 'agents', 'wtfp'),
+        dest: 'agents/wtfp',
+        type: 'dir'
+      },
+      {
+        id: 'scripts',
+        src: path.join(ROOT, 'bin', 'lib'),
+        dest: 'bin',
+        type: 'dir'
+      }
+    ]
+  },
+  opencode: {
+    name: 'OpenCode',
+    configDirEnv: 'OPENCODE_CONFIG_DIR',
+    defaultDir: '.opencode',
+    components: [
+      {
+        id: 'workflows',
+        src: path.join(ROOT, 'core', 'write-the-f-paper'),
+        dest: 'write-the-f-paper',
+        type: 'dir'
+      },
+      {
+        id: 'commands',
+        src: path.join(ROOT, 'vendors', 'opencode', 'commands', 'wtfp'),
+        dest: 'commands/wtfp',
+        type: 'dir'
+      },
+      {
+        id: 'agents',
+        src: path.join(ROOT, 'vendors', 'opencode', 'agents', 'wtfp'),
+        dest: 'agents/wtfp',
+        type: 'dir'
+      },
+      {
+        id: 'scripts',
+        src: path.join(ROOT, 'bin', 'lib'),
+        dest: 'bin',
+        type: 'dir'
+      }
+    ]
+  }
 };
 
 module.exports = MANIFEST;

package/bin/lib/scholar-lookup.js

@@ -0,0 +1,188 @@
+const https = require('https');
+const querystring = require('querystring');
+
+/**
+ * SerpAPI Google Scholar Wrapper
+ * 
+ * Provides access to Google Scholar data via SerpAPI.
+ * Used for high-value "seminal" queries to get citation velocity and cluster IDs.
+ * 
+ * Env:
+ *  - SERPAPI_KEY: Required for operation.
+ */
+
+const HOST = 'serpapi.com';
+const PATH = '/search';
+
+const usage = {
+  queries: 0,
+  // Default budget: 100 queries/month (~$5)
+  monthlyBudget: 100,
+  
+  canQuery() {
+    return this.queries < this.monthlyBudget;
+  },
+  
+  recordQuery() {
+    this.queries++;
+    if (this.queries % 10 === 0) {
+      // console.error(`[Scholar] API usage: ${this.queries}/${this.monthlyBudget}`);
+    }
+  }
+};
+
+function getApiKey() {
+  return process.env.SERPAPI_KEY;
+}
+
+function isAvailable() {
+  return !!getApiKey();
+}
+
+function request(params) {
+  return new Promise((resolve, reject) => {
+    const key = getApiKey();
+    if (!key) {
+      return reject(new Error('SERPAPI_KEY not set'));
+    }
+    if (!usage.canQuery()) {
+      return reject(new Error('Monthly budget exceeded'));
+    }
+
+    usage.recordQuery();
+
+    const q = querystring.stringify({
+      ...params,
+      api_key: key,
+      engine: 'google_scholar'
+    });
+
+    const options = {
+      hostname: HOST,
+      path: `${PATH}?${q}`,
+      method: 'GET'
+    };
+
+    const req = https.request(options, (res) => {
+      let data = '';
+      res.on('data', c => data += c);
+      res.on('end', () => {
+        if (res.statusCode !== 200) {
+          return reject(new Error(`SerpAPI Error: ${res.statusCode} ${data}`));
+        }
+        try {
+          resolve(JSON.parse(data));
+        } catch (e) {
+          reject(e);
+        }
+      });
+    });
+
+    req.on('error', reject);
+    req.end();
+  });
+}
+
+/**
+ * Search Google Scholar
+ * @param {string} query 
+ * @param {Object} options { yearLow, yearHigh, limit }
+ */
+async function search(query, options = {}) {
+  const params = {
+    q: query,
+    num: options.limit || 10
+  };
+  
+  if (options.yearLow) params.as_ylo = options.yearLow;
+  if (options.yearHigh) params.as_yhi = options.yearHigh;
+
+  const data = await request(params);
+  return (data.organic_results || []).map(mapResult);
+}
+
+/**
+ * Get paper by Cluster ID
+ * @param {string} clusterId 
+ */
+async function getByClusterId(clusterId) {
+  const data = await request({ cluster: clusterId });
+  // When searching by cluster, it returns list of versions.
+  // We usually want the first one or metadata about the cluster.
+  // SerpAPI "cluster" usually returns "organic_results" which are the versions.
+  const results = data.organic_results || [];
+  if (results.length > 0) return mapResult(results[0]);
+  return null;
+}
+
+/**
+ * Get citing papers
+ * @param {string} clusterId 
+ * @param {number} limit 
+ */
+async function getCitingPapers(clusterId, limit = 10) {
+  const data = await request({ 
+    cites: clusterId,
+    num: limit 
+  });
+  return (data.organic_results || []).map(mapResult);
+}
+
+function mapResult(item) {
+  // Extract cluster ID
+  let clusterId = null;
+  // Try to find it in links or specific fields if SerpAPI provides it directly
+  // SerpAPI usually puts it in inline_links -> cited_by -> serpapi_link (cites=ID)
+  // or versions -> serpapi_link (cluster=ID)
+  
+  if (item.inline_links && item.inline_links.cited_by && item.inline_links.cited_by.serpapi_link) {
+    const match = item.inline_links.cited_by.serpapi_link.match(/cites=(\w+)/);
+    if (match) clusterId = match[1];
+  }
+  
+  return {
+    source: 'google_scholar',
+    title: item.title,
+    clusterId: clusterId || item.cluster_id, // Sometimes provided directly
+    link: item.link,
+    snippet: item.snippet,
+    publication_info: item.publication_info,
+    citationCount: item.inline_links && item.inline_links.cited_by ? item.inline_links.cited_by.total : 0,
+    year: extractYear(item.publication_info ? item.publication_info.summary : ''),
+    authors: extractAuthors(item.publication_info ? item.publication_info.summary : ''),
+    venue: extractVenue(item.publication_info ? item.publication_info.summary : '')
+  };
+}
+
+function extractYear(summary) {
+  const match = summary.match(/\b(19|20)\d{2}\b/);
+  return match ? parseInt(match[0]) : null;
+}
+
+function extractAuthors(summary) {
+  // "A Author, B Author - Venue, 2020 - publisher"
+  if (!summary) return [];
+  const parts = summary.split('-');
+  if (parts.length > 0) {
+    return parts[0].split(',').map(s => ({ name: s.trim() }));
+  }
+  return [];
+}
+
+function extractVenue(summary) {
+  if (!summary) return null;
+  const parts = summary.split('-');
+  if (parts.length > 1) {
+    // "Venue, Year" usually
+    return parts[1].split(',')[0].trim();
+  }
+  return null;
+}
+
+module.exports = {
+  isAvailable,
+  search,
+  getByClusterId,
+  getCitingPapers,
+  usage
+};

package/bin/lib/semantic-scholar.js

@@ -0,0 +1,184 @@
+const https = require('https');
+const querystring = require('querystring');
+
+/**
+ * Semantic Scholar API Wrapper
+ * 
+ * Provides search and lookup capabilities for Semantic Scholar Graph API v1.
+ * Handles rate limiting with exponential backoff.
+ * 
+ * Env:
+ *  - S2_API_KEY: Optional API key for higher rate limits.
+ */
+
+const API_KEY = process.env.S2_API_KEY;
+const BASE_HOST = 'api.semanticscholar.org';
+const BASE_PATH = '/graph/v1';
+
+const RETRY_CONFIG = {
+  maxRetries: 5,
+  baseDelay: 1000,
+  maxDelay: 16000
+};
+
+class SemanticScholarError extends Error {
+  constructor(message, statusCode, retryAfter) {
+    super(message);
+    this.name = 'SemanticScholarError';
+    this.statusCode = statusCode;
+    this.retryAfter = retryAfter;
+  }
+}
+
+/**
+ * Sleep helper
+ */
+const sleep = (ms) => new Promise(resolve => setTimeout(resolve, ms));
+
+/**
+ * Make an HTTP request with retry logic
+ */
+async function request(endpoint, params = {}) {
+  const query = querystring.stringify(params);
+  const path = `${BASE_PATH}${endpoint}?${query}`;
+  
+  let attempt = 0;
+
+  while (attempt <= RETRY_CONFIG.maxRetries) {
+    try {
+      return await doRequest(path);
+    } catch (error) {
+      if (error instanceof SemanticScholarError && error.statusCode === 429) {
+        attempt++;
+        if (attempt > RETRY_CONFIG.maxRetries) throw error;
+        
+        // Use Retry-After header if available, else exponential backoff
+        const delay = error.retryAfter 
+          ? parseInt(error.retryAfter, 10) * 1000 
+          : Math.min(RETRY_CONFIG.maxDelay, RETRY_CONFIG.baseDelay * Math.pow(2, attempt - 1));
+        
+        // console.error(`[S2] Rate limited. Retrying in ${delay}ms...`);
+        await sleep(delay);
+        continue;
+      }
+      throw error;
+    }
+  }
+}
+
+function doRequest(path) {
+  return new Promise((resolve, reject) => {
+    const options = {
+      hostname: BASE_HOST,
+      path: path,
+      method: 'GET',
+      headers: {
+        'User-Agent': 'WTF-P/0.4.0 (citation-expert)',
+      }
+    };
+
+    if (API_KEY) {
+      options.headers['x-api-key'] = API_KEY;
+    }
+
+    const req = https.request(options, (res) => {
+      let data = '';
+
+      res.on('data', (chunk) => data += chunk);
+
+      res.on('end', () => {
+        if (res.statusCode === 429) {
+          const retryAfter = res.headers['retry-after'];
+          return reject(new SemanticScholarError('Rate limit exceeded', 429, retryAfter));
+        }
+
+        if (res.statusCode >= 400) {
+          return reject(new SemanticScholarError(`API Error: ${res.statusCode} ${data}`, res.statusCode));
+        }
+
+        try {
+          const json = JSON.parse(data);
+          resolve(json);
+        } catch (e) {
+          reject(new Error(`Failed to parse response: ${e.message}`));
+        }
+      });
+    });
+
+    req.on('error', (e) => reject(new Error(`Request failed: ${e.message}`)));
+    req.on('timeout', () => {
+      req.destroy();
+      reject(new Error('Request timed out'));
+    });
+    
+    // Set a reasonable timeout (10s)
+    req.setTimeout(10000);
+    req.end();
+  });
+}
+
+/**
+ * Search for papers
+ * @param {string} query 
+ * @param {Object} options 
+ */
+async function search(query, options = {}) {
+  const limit = Math.min(options.limit || 10, 100);
+  const fields = options.fields || [
+    'paperId', 'externalIds', 'title', 'abstract', 'venue', 'year', 
+    'citationCount', 'influentialCitationCount', 'authors', 
+    'publicationTypes', 'openAccessPdf'
+  ];
+
+  const params = {
+    query,
+    limit,
+    fields: fields.join(',')
+  };
+
+  if (options.year) params.year = options.year;
+
+  const response = await request('/paper/search', params);
+  return response.data || [];
+}
+
+/**
+ * Get paper by ID
+ * @param {string} id - S2 PaperId, DOI, ArXivId, etc.
+ * @param {string[]} fields 
+ */
+async function getPaper(id, fields = []) {
+  const defaultFields = [
+    'paperId', 'externalIds', 'title', 'abstract', 'venue', 'year', 
+    'citationCount', 'influentialCitationCount', 'authors', 
+    'publicationTypes', 'openAccessPdf'
+  ];
+  
+  const params = {
+    fields: (fields.length > 0 ? fields : defaultFields).join(',')
+  };
+
+  return await request(`/paper/${id}`, params);
+}
+
+/**
+ * Get citations for a paper
+ * @param {string} paperId 
+ * @param {number} limit 
+ */
+async function getCitations(paperId, limit = 20) {
+  const params = {
+    limit,
+    fields: 'title,year,citationCount,authors' // Minimal fields for citations
+  };
+  
+  const response = await request(`/paper/${paperId}/citations`, params);
+  return response.data || [];
+}
+
+module.exports = {
+  search,
+  getPaper,
+  getCitations,
+  SemanticScholarError
+};

package/bin/lib/utils.js

@@ -160,21 +160,33 @@ function detectInstallation(vendorDir) {
     hasCommands: false,
     hasWorkflows: false,
     hasSkills: false,
+    hasAgents: false,
+    hasMcp: false,
+    hasBin: false,
     version: null,
     partial: false,
     corrupt: false,
     commandFiles: [],
     workflowFiles: [],
-    skillFiles: []
+    skillFiles: [],
+    agentFiles: [],
+    mcpFiles: [],
+    binFiles: []
   };
 
   const commandsDir = path.join(vendorDir, 'commands', 'wtfp');
   const workflowsDir = path.join(vendorDir, 'write-the-f-paper');
   const skillsDir = path.join(vendorDir, 'skills', 'wtfp');
+  const agentsDir = path.join(vendorDir, 'agents', 'wtfp');
+  const mcpDir = path.join(vendorDir, 'mcp');
+  const binDir = path.join(vendorDir, 'bin');
 
   result.hasCommands = fs.existsSync(commandsDir);
   result.hasWorkflows = fs.existsSync(workflowsDir);
   result.hasSkills = fs.existsSync(skillsDir);
+  result.hasAgents = fs.existsSync(agentsDir);
+  result.hasMcp = fs.existsSync(mcpDir);
+  result.hasBin = fs.existsSync(binDir);
 
   if (result.hasCommands) {
     result.commandFiles = collectFiles(commandsDir);
@@ -185,6 +197,15 @@ function detectInstallation(vendorDir) {
   if (result.hasSkills) {
     result.skillFiles = collectFiles(skillsDir);
   }
+  if (result.hasAgents) {
+    result.agentFiles = collectFiles(agentsDir);
+  }
+  if (result.hasMcp) {
+    result.mcpFiles = collectFiles(mcpDir);
+  }
+  if (result.hasBin) {
+    result.binFiles = collectFiles(binDir);
+  }
 
   // Read version info
   const versionData = readInstalledVersion(vendorDir);