wtf-p 0.3.0 → 0.5.0

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 };

package/bin/lib/checkpoint.js

@@ -0,0 +1,183 @@
+/**
+ * Checkpoint - Save and restore paper state bundles
+ *
+ * Captures complete .planning/ state as a git-tagged checkpoint
+ * that can be restored in a new session for full context recovery.
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { execSync } = require('child_process');
+
+/**
+ * Create a checkpoint of current paper state
+ * @param {Object} options
+ * @param {string} options.planningDir - Path to .planning/
+ * @param {string} options.label - Checkpoint label (e.g., "pre-discussion", "draft-1")
+ * @param {string} [options.note] - Optional note about checkpoint context
+ * @returns {Object} - { tag, files, timestamp }
+ */
+function createCheckpoint({ planningDir, label, note }) {
+  if (!fs.existsSync(planningDir)) {
+    throw new Error('.planning/ directory not found');
+  }
+
+  const timestamp = new Date().toISOString().replace(/[:.]/g, '-').slice(0, 19);
+  const tag = `wtfp-checkpoint/${label}-${timestamp}`;
+
+  // Collect all state files
+  const files = collectFiles(planningDir);
+
+  // Stage all planning files
+  try {
+    execSync(`git add ${planningDir}`, { stdio: 'pipe' });
+  } catch (e) {
+    // May fail if no changes — that's OK
+  }
+
+  // Check if there are staged changes
+  const status = execSync('git status --porcelain', { encoding: 'utf8' });
+  const hasChanges = status.trim().length > 0;
+
+  if (hasChanges) {
+    const commitMsg = `checkpoint: ${label}${note ? `\n\n${note}` : ''}`;
+    execSync(`git commit -m "${commitMsg.replace(/"/g, '\\"')}"`, { stdio: 'pipe' });
+  }
+
+  // Create annotated tag
+  const tagMsg = [
+    `WTF-P Checkpoint: ${label}`,
+    `Timestamp: ${timestamp}`,
+    `Files: ${files.length}`,
+    note ? `Note: ${note}` : '',
+  ].filter(Boolean).join('\n');
+
+  execSync(`git tag -a "${tag}" -m "${tagMsg.replace(/"/g, '\\"')}"`, { stdio: 'pipe' });
+
+  return { tag, files: files.length, timestamp };
+}
+
+/**
+ * Restore a checkpoint by tag name
+ * @param {string} tag - Git tag to restore from
+ * @returns {Object} - { restored, files }
+ */
+function restoreCheckpoint(tag) {
+  // Verify tag exists
+  try {
+    execSync(`git tag -l "${tag}"`, { encoding: 'utf8', stdio: 'pipe' });
+  } catch (e) {
+    throw new Error(`Checkpoint tag not found: ${tag}`);
+  }
+
+  // Restore .planning/ from the tagged commit
+  try {
+    execSync(`git checkout "${tag}" -- .planning/`, { stdio: 'pipe' });
+    return { restored: true, tag };
+  } catch (e) {
+    throw new Error(`Failed to restore checkpoint: ${e.message}`);
+  }
+}
+
+/**
+ * List available checkpoints
+ * @returns {Array} - List of { tag, date, label, message }
+ */
+function listCheckpoints() {
+  try {
+    const tags = execSync('git tag -l "wtfp-checkpoint/*" --sort=-creatordate', {
+      encoding: 'utf8',
+      stdio: 'pipe',
+    }).trim();
+
+    if (!tags) return [];
+
+    return tags.split('\n').map(tag => {
+      let message = '';
+      try {
+        message = execSync(`git tag -l "${tag}" -n1`, {
+          encoding: 'utf8',
+          stdio: 'pipe',
+        }).trim();
+      } catch (e) { /* ignore */ }
+
+      const parts = tag.replace('wtfp-checkpoint/', '').split('-');
+      const label = parts.slice(0, -6).join('-'); // Remove timestamp portion
+
+      return { tag, label, message };
+    });
+  } catch (e) {
+    return [];
+  }
+}
+
+/**
+ * Generate a handoff document for session continuity
+ * @param {string} planningDir - Path to .planning/
+ * @returns {string} - Markdown content for HANDOFF.md
+ */
+function generateHandoff(planningDir) {
+  const statePath = path.join(planningDir, 'STATE.md');
+  const configPath = path.join(planningDir, 'config.json');
+
+  const state = fs.existsSync(statePath) ? fs.readFileSync(statePath, 'utf8') : '';
+  let config = {};
+  try {
+    config = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+  } catch (e) { /* ignore */ }
+
+  // Extract position from STATE.md
+  const positionMatch = state.match(/Section:\s*(\d+)\s*of\s*(\d+)/i);
+  const wordsMatch = state.match(/Words?:\s*(\d+)\s*\/\s*(\d+)/i);
+
+  const sections = [];
+  sections.push('# Session Handoff');
+  sections.push(`\nGenerated: ${new Date().toISOString()}`);
+  sections.push(`\n## Position`);
+
+  if (positionMatch) {
+    sections.push(`- Section: ${positionMatch[1]} of ${positionMatch[2]}`);
+  }
+  if (wordsMatch) {
+    sections.push(`- Words: ${wordsMatch[1]} / ${wordsMatch[2]}`);
+  }
+  if (config.model_profile) {
+    sections.push(`- Profile: ${config.model_profile}`);
+  }
+
+  sections.push(`\n## Resume With`);
+  sections.push('```');
+  sections.push('/wtfp:resume-writing');
+  sections.push('```');
+
+  return sections.join('\n');
+}
+
+// --- Helpers ---
+
+function collectFiles(dir) {
+  const files = [];
+
+  function walk(d) {
+    if (!fs.existsSync(d)) return;
+    const entries = fs.readdirSync(d, { withFileTypes: true });
+    for (const entry of entries) {
+      const full = path.join(d, entry.name);
+      if (entry.isDirectory()) {
+        walk(full);
+      } else {
+        files.push(full);
+      }
+    }
+  }
+
+  walk(dir);
+  return files;
+}
+
+module.exports = {
+  createCheckpoint,
+  restoreCheckpoint,
+  listCheckpoints,
+  generateHandoff,
+};