wtf-p 0.2.0 → 0.4.0

package/bin/lib/wcn-compiler.js

@@ -0,0 +1,226 @@
+/**
+ * WCN Compiler (Workflow Compression Notation)
+ * A robust, state-machine based compiler for converting Verbose Markdown to Compressed WCN.
+ */
+
+const FLUFF_PATTERNS = [
+  /This ensures[^.]*\./g,
+  /This is important[^.]*\./g,
+  /Note that[^.]*\./g,
+  /Keep in mind[^.]*\./g,
+  /Remember that[^.]*\./g,
+  /As mentioned[^.]*\./g,
+  /It is important to[^.]*\./g,
+];
+
+class WCNCompiler {
+  constructor() {
+    this.lines = [];
+    this.output = [];
+    this.state = 'ROOT'; // ROOT, STEP, BASH
+    this.context = {};
+  }
+
+  compile(markdown) {
+    // 1. Pre-process: Remove fluff and normalize
+    let cleanMd = markdown;
+    FLUFF_PATTERNS.forEach(p => cleanMd = cleanMd.replace(p, ''));
+    
+    this.lines = cleanMd.split('\n');
+    this.output = [];
+    this.state = 'ROOT';
+    
+    // 2. Parse Line by Line
+    for (let i = 0; i < this.lines.length; i++) {
+      const line = this.lines[i].trim();
+      this.processLine(line, i);
+    }
+
+    // 3. Post-process: Clean up excessive newlines
+    return this.output.join('\n').replace(/\n{3,}/g, '\n\n').trim();
+  }
+
+  processLine(line, index) {
+    // Handle State Transitions
+    if (this.state === 'ROOT') {
+      if (line.startsWith('<step')) {
+        this.enterStep(line);
+      } else if (line.startsWith('<context>')) {
+        this.enterContext();
+      } else if (line.startsWith('**If') && line.endsWith(':**')) {
+        // Handle standalone conditionals (outside steps, rare but possible)
+        this.parseConditional(line, index);
+      } else if (line.startsWith('**Route')) {
+        this.parseRoute(line, index);
+      } else if (!line.startsWith('</')) {
+        // Pass through other content, but minimal
+        // We generally skip prose outside steps in WCN unless it's structural
+        if (line.startsWith('#') || line.startsWith('---')) {
+          this.output.push(line);
+        }
+      }
+    } else if (this.state === 'STEP') {
+      if (line.startsWith('</step>')) {
+        this.exitStep();
+      } else if (line.startsWith('```bash')) {
+        this.state = 'BASH';
+      } else if (line.startsWith('**If') && line.endsWith(':**')) {
+        this.parseConditional(line, index);
+      } else if (line.toLowerCase().startsWith('parse and internalize:')) {
+        this.parseParseBlock(index);
+      } else if (line.trim().startsWith('- ') || line.trim().startsWith('* ')) {
+        // Capture bullet points as instructions
+        this.output.push(line.trim());
+      } else if (line.trim().startsWith('**') && !line.includes('If')) {
+        // Capture bold instructions
+        this.output.push(line.trim());
+      }
+    } else if (this.state === 'BASH') {
+      if (line.startsWith('```')) {
+        this.state = 'STEP';
+      } else {
+        // Capture bash command (first line usually sufficient for WCN)
+        if (line && !line.startsWith('#')) {
+          this.output.push(`RUN: ${line}`);
+          // Skip rest of bash block for WCN brevity? 
+          // Current logic captures all commands. Let's capture all.
+        }
+      }
+    }
+  }
+
+  enterStep(line) {
+    this.state = 'STEP';
+    // Parse attributes: name="foo" priority="bar"
+    const nameMatch = line.match(/name="([^"]+)"/);
+    const priorityMatch = line.match(/priority="([^"]+)"/);
+    
+    const name = nameMatch ? nameMatch[1] : 'unknown';
+    const pAttr = priorityMatch ? ` p=${priorityMatch[1] === 'first' ? '1' : priorityMatch[1]}` : '';
+    
+    this.output.push(`[step:${name}${pAttr}]`);
+  }
+
+  exitStep() {
+    this.output.push('[/step]');
+    this.state = 'ROOT';
+  }
+
+  enterContext() {
+    // Context is usually multiline, handled by looking ahead or buffering
+    // For simplicity, we'll scan ahead here since we have full lines access
+    // But sticking to line-by-line:
+    // Actually, Regex is better for Context blocks as they are simple <context>...</context>
+    // Let's defer this to a specialized Regex pass *before* line processing?
+    // Or just look ahead now.
+    // Let's skip for now and rely on a pre-pass replacement for Context, similar to current tool.
+    // Why? Because Context is global metadata, usually at top.
+  }
+
+  parseConditional(line, index) {
+    // **If mode="yolo":**
+    const condition = line.replace(/\*\*If\s+/, '').replace(/:\*\*/, '').trim().replace(/["']/g, '');
+    
+    // Look ahead for the action
+    // Usually the next line or the line after
+    let action = '';
+    for (let i = 1; i < 5; i++) {
+      const next = this.lines[index + i];
+      if (next && next.trim()) {
+        action = next.trim();
+        break;
+      }
+    }
+
+    if (action) {
+      // Simplify action text
+      if (action.length > 50) action = action.substring(0, 47) + '...';
+      this.output.push(`IF ${condition} → ${action}`);
+    }
+  }
+
+  parseParseBlock(index) {
+    // Parse and internalize:
+    // - Item 1
+    // - Item 2
+    const fields = [];
+    for (let i = 1; i < 10; i++) {
+      const next = this.lines[index + i];
+      if (!next || (!next.trim().startsWith('-') && !next.trim().startsWith('*'))) break;
+      
+      const field = next.replace(/^[-*]\s+/, '').trim().split(' ')[0].toLowerCase().replace(/\s+/g, '_');
+      fields.push(field);
+    }
+    
+    if (fields.length > 0) {
+      this.output.push(`PARSE: ${fields.join(', ')}`);
+    }
+  }
+
+  parseRoute(line, index) {
+    // **Route A: Title**
+    const match = line.match(/\*\*Route\s+([A-Z]):\s*([^*]+)\*\*/);
+    if (!match) return;
+
+    // We need to buffer the route table
+    // This is hard to do line-by-line without buffering.
+    // Let's assume we handle Routes via Regex pre-pass like the original, 
+    // OR we detect the start of a route block and switch state.
+    // Given the complexity, let's stick to the Regex for Routes/Modes/Context
+    // and use State Machine for the detailed STEP logic which is where the fragility usually is.
+  }
+}
+
+/**
+ * Hybrid Compiler:
+ * 1. Uses Regex for high-level blocks (Context, Routes, Modes)
+ * 2. Uses State Machine for Steps (the most complex part)
+ */
+function compile(markdown) {
+  let result = markdown;
+
+  // 1. Remove fluff
+  FLUFF_PATTERNS.forEach(p => result = result.replace(p, ''));
+
+  // 2. Compress Context (Regex is fine here)
+  result = result.replace(/<context>\s*([\s\S]*?)<\/context>/g, (match, content) => {
+    const files = content.match(/@[^\s\n]+/g) || [];
+    if (files.length === 0) return '';
+    const simplified = files.map(f => f.replace('@.planning/', ''));
+    return `@context{${simplified.join(',')}}`;
+  });
+
+  // 3. Compress Routes (Regex is fine here)
+  const routes = [];
+  result = result.replace(/\*\*Route\s+([A-Z]):\s*([^*]+)\*\*\s*([\s\S]*?)(?=\*\*Route|<step|$)/g, (match, id, title, content) => {
+    // Extract next step logic
+    const nextMatch = content.match(/\`\/wtfp:([^`]+)\`/);
+    const next = nextMatch ? `/wtfp:${nextMatch[1]}` : 'continue';
+    routes.push(`  ${title.trim().toLowerCase().replace(/\s+/g, '_')} → "${title.trim()}" → ${next}`);
+    return '';
+  });
+  if (routes.length > 0) {
+    result = result + '\n\nROUTE{condition → output → next}:\n' + routes.join('\n');
+  }
+
+  // 4. Compress Modes (Regex is fine here)
+  const modes = [];
+  result = result.replace(/\*\*If\s+mode="([^"]+)":\*\*\s*\n((?:[-*]\s+[^\n]+\n?)+)/g, (match, mode, items) => {
+    const itemList = items.split('\n').filter(l => l.trim()).map(l => l.replace(/^[-*]\s+/, '').trim());
+    modes.push(`  ${mode} | ${itemList[0] || ''}`);
+    return '';
+  });
+  if (modes.length > 0) {
+    result = 'MODE{name,action}:\n' + modes.join('\n') + '\n\n' + result;
+  }
+
+  // 5. Compress Steps using State Machine (The Core Logic)
+  const compiler = new WCNCompiler();
+  // We only run the compiler on the text that remains (which should be mostly steps)
+  // But wait, the compiler expects full text to find steps.
+  // Let's pass the text to the compiler, but the compiler only outputs Step blocks and structural elements.
+  
+  return compiler.compile(result);
+}
+
+module.exports = { compile, WCNCompiler };

package/bin/uninstall.js

@@ -102,7 +102,9 @@ if (hasHelp) {
 
   ${c.yellow('What gets removed:')}
     ${c.dim('commands/wtfp/')}         - WTF-P slash commands
-    ${c.dim('write-the-f-paper/')}     - WTF-P skill and workflows
+    ${c.dim('write-the-f-paper/')}     - WTF-P workflows
+    ${c.dim('skills/wtfp/')}           - WTF-P skills
+    ${c.dim('.claude-plugin/')}        - Plugin manifest
     ${c.dim('.wtfp-version')}          - Version tracking file
 
   ${c.yellow('What stays intact:')}
@@ -200,9 +202,9 @@ async function uninstall(isGlobal) {
 
   // Detect installation
   const installed = detectInstallation(claudeDir);
-  const totalFiles = installed.commandFiles.length + installed.skillFiles.length;
+  const totalFiles = installed.commandFiles.length + installed.workflowFiles.length + installed.skillFiles.length;
 
-  if (!installed.hasCommands && !installed.hasSkill) {
+  if (!installed.hasCommands && !installed.hasWorkflows && !installed.hasSkills) {
     out.log(`  ${c.yellow('No WTF-P installation found in ' + locationLabel)}\n`);
 
     // Check for backups if requested
@@ -252,13 +254,21 @@ async function uninstall(isGlobal) {
   out.log(`  ${c.yellow('Found WTF-P installation:')}\n`);
 
   const commandsDir = path.join(claudeDir, 'commands', 'wtfp');
-  const skillDir = path.join(claudeDir, 'write-the-f-paper');
+  const workflowsDir = path.join(claudeDir, 'write-the-f-paper');
+  const skillsDir = path.join(claudeDir, 'skills', 'wtfp');
+  const pluginDir = path.join(claudeDir, '.claude-plugin');
 
   if (installed.hasCommands) {
     out.log(`    ${c.cyan('commands/wtfp/')} (${installed.commandFiles.length} files)`);
   }
-  if (installed.hasSkill) {
-    out.log(`    ${c.cyan('write-the-f-paper/')} (${installed.skillFiles.length} files)`);
+  if (installed.hasWorkflows) {
+    out.log(`    ${c.cyan('write-the-f-paper/')} (${installed.workflowFiles.length} files)`);
+  }
+  if (installed.hasSkills) {
+    out.log(`    ${c.cyan('skills/wtfp/')} (${installed.skillFiles.length} files)`);
+  }
+  if (fs.existsSync(pluginDir)) {
+    out.log(`    ${c.cyan('.claude-plugin/')} (manifest)`);
   }
   if (installed.version) {
     out.log(`    ${c.cyan(VERSION_FILE)} (version tracking)`);
@@ -304,12 +314,16 @@ async function uninstall(isGlobal) {
     fs.mkdirSync(backupDir, { recursive: true });
 
     if (installed.hasCommands) {
-      const dest = path.join(backupDir, 'commands', 'wtfp');
-      copyDir(commandsDir, dest);
+      copyDir(commandsDir, path.join(backupDir, 'commands', 'wtfp'));
+    }
+    if (installed.hasWorkflows) {
+      copyDir(workflowsDir, path.join(backupDir, 'write-the-f-paper'));
     }
-    if (installed.hasSkill) {
-      const dest = path.join(backupDir, 'write-the-f-paper');
-      copyDir(skillDir, dest);
+    if (installed.hasSkills) {
+      copyDir(skillsDir, path.join(backupDir, 'skills', 'wtfp'));
+    }
+    if (fs.existsSync(pluginDir)) {
+      copyDir(pluginDir, path.join(backupDir, '.claude-plugin'));
     }
 
     const backupLabel = backupDir.replace(os.homedir(), '~').replace(process.cwd(), '.');
@@ -332,11 +346,31 @@ async function uninstall(isGlobal) {
     }
   }
 
-  if (installed.hasSkill) {
-    removeDir(skillDir);
+  if (installed.hasWorkflows) {
+    removeDir(workflowsDir);
     out.log(`  ${c.red('-')} ${c.dim('write-the-f-paper/')}`);
   }
 
+  if (installed.hasSkills) {
+    removeDir(skillsDir);
+    out.log(`  ${c.red('-')} ${c.dim('skills/wtfp/')}`);
+    
+    // Clean up empty skills dir
+    const parentSkillsDir = path.join(claudeDir, 'skills');
+    if (fs.existsSync(parentSkillsDir)) {
+      const remaining = fs.readdirSync(parentSkillsDir);
+      if (remaining.length === 0) {
+        fs.rmdirSync(parentSkillsDir);
+        out.log(`  ${c.red('-')} ${c.dim('skills/')} ${c.dim('(empty)')}`);
+      }
+    }
+  }
+
+  if (fs.existsSync(pluginDir)) {
+    removeDir(pluginDir);
+    out.log(`  ${c.red('-')} ${c.dim('.claude-plugin/')}`);
+  }
+
   // Remove version file
   const versionFile = path.join(claudeDir, VERSION_FILE);
   if (fs.existsSync(versionFile)) {
@@ -379,8 +413,8 @@ async function promptLocation() {
   const globalInstalled = detectInstallation(globalPath);
   const localInstalled = detectInstallation(localPath);
 
-  const hasGlobalInstall = globalInstalled.hasCommands || globalInstalled.hasSkill;
-  const hasLocalInstall = localInstalled.hasCommands || localInstalled.hasSkill;
+  const hasGlobalInstall = globalInstalled.hasCommands || globalInstalled.hasWorkflows || globalInstalled.hasSkills;
+  const hasLocalInstall = localInstalled.hasCommands || localInstalled.hasWorkflows || localInstalled.hasSkills;
 
   if (!hasGlobalInstall && !hasLocalInstall) {
     out.log(`  ${c.yellow('No WTF-P installation found.')}\n`);
@@ -394,14 +428,14 @@ async function promptLocation() {
   out.log(`  ${c.yellow('Where would you like to uninstall from?')}\n`);
 
   if (hasGlobalInstall) {
-    const count = globalInstalled.commandFiles.length + globalInstalled.skillFiles.length;
+    const count = globalInstalled.commandFiles.length + globalInstalled.workflowFiles.length + globalInstalled.skillFiles.length;
     out.log(`  ${c.cyan('1)')} Global ${c.dim('(' + globalLabel + ')')} - ${count} files`);
   } else {
     out.log(`  ${c.dim('1) Global (' + globalLabel + ') - not installed')}`);
   }
 
   if (hasLocalInstall) {
-    const count = localInstalled.commandFiles.length + localInstalled.skillFiles.length;
+    const count = localInstalled.commandFiles.length + localInstalled.workflowFiles.length + localInstalled.skillFiles.length;
     out.log(`  ${c.cyan('2)')} Local  ${c.dim('(./.claude)')} - ${count} files`);
   } else {
     out.log(`  ${c.dim('2) Local (./.claude) - not installed')}`);

package/core/write-the-f-paper/templates/posters/basic.md

@@ -0,0 +1,34 @@
+---
+marp: true
+theme: uncover
+size: 4:3
+---
+
+# [Poster Title]
+
+## Authors
+Author 1, Author 2
+
+---
+
+## Introduction
+- Problem statement
+- Importance
+
+---
+
+## Methodology
+- Approach
+- Implementation details
+
+---
+
+## Results
+- Key findings
+- Charts (use ECharts!)
+
+---
+
+## Conclusion
+- Summary
+- Future work

package/core/write-the-f-paper/templates/slides/basic.md

@@ -0,0 +1,31 @@
+---
+marp: true
+theme: gaia
+_class: lead
+---
+
+# [Presentation Title]
+## [Subtitle]
+
+Author Name
+
+---
+
+# Agenda
+1. Introduction
+2. Problem Statement
+3. Methodology
+4. Results
+5. Conclusion
+
+---
+
+# Introduction
+- Context
+- High-level overview
+
+---
+
+# Conclusion
+- Final thoughts
+- Q&A

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wtf-p",
-  "version": "0.2.0",
+  "version": "0.4.0",
   "description": "The G.O.A.T. meta-prompting system for 10x researchers who need to submit papers and projects and proposals YESTERDAY.",
   "bin": {
     "wtfp": "bin/install.js",
@@ -8,7 +8,7 @@
     "wtf-p-uninstall": "bin/uninstall.js"
   },
   "scripts": {
-    "test": "node test/sanity.js && node test/paths.js",
+    "test": "node test/sanity.js && node test/paths.js && node test/linter.js",
     "test:integration": "node test/integration.js",
     "test:all": "npm test && npm run test:integration",
     "preflight": "node scripts/preflight.js",
@@ -16,9 +16,17 @@
   },
   "files": [
     "bin",
-    "commands",
-    "write-the-f-paper"
+    "core",
+    "vendors"
   ],
+  "peerDependencies": {
+    "@marp-team/marp-cli": ">=3.0.0"
+  },
+  "peerDependenciesMeta": {
+    "@marp-team/marp-cli": {
+      "optional": true
+    }
+  },
   "keywords": [
     "claude",
     "claude-code",

package/vendors/claude/.claude-plugin/plugin.json

@@ -0,0 +1,12 @@
+{
+  "name": "wtf-p",
+  "description": "Academic writing toolkit - Paper, Proposal, Presentation, Poster",
+  "version": "0.3.0",
+  "author": {
+    "name": "akougkas",
+    "url": "https://github.com/akougkas"
+  },
+  "homepage": "https://github.com/akougkas/wtf-p",
+  "repository": "https://github.com/akougkas/wtf-p",
+  "license": "MIT"
+}

package/vendors/claude/agents/wtfp/citation-expert.md

@@ -0,0 +1,45 @@
+---
+name: citation-expert
+description: Academic citation specialist. Searches papers, manages BibTeX, and identifies literature gaps.
+allowed-tools:
+  - Bash
+  - Read
+  - Write
+---
+
+# Citation Expert
+
+You are a senior academic librarian and bibliometric specialist. Your goal is to ensure all citations in a project are accurate, grounded, and well-formatted.
+
+## Tools
+You have access to specialized CLI tools for citation management:
+
+1.  **Retrieval:** `node ~/.claude/bin/citation-fetcher.js "<query>"`
+    - Use this to find new papers and get their BibTeX.
+    - Source: CrossRef / Semantic Scholar.
+
+2.  **Bibliography Management:** `node ~/.claude/bin/bib-index.js <command> ...`
+    - `index <file>`: List all keys in a bib file.
+    - `get <file> <key>`: Read a specific entry.
+    - `search <file> <query>`: Find entries by keyword.
+
+## Capabilities
+
+1.  **Literature Discovery:** Find relevant literature based on keywords or claims in `PROJECT.md`.
+2.  **Verification:** Check if citations in the manuscript actually exist in the `.bib` file.
+3.  **Formatting:** Ensure BibTeX entries follow standard conventions.
+4.  **Gap Analysis:** Compare current citations against the core argument.
+
+## Principles
+
+- **Precision Over Recall:** Prefer a few highly relevant citations.
+- **No Direct Writes:** NEVER overwrite the user's `references.bib`. Always create a `suggested.bib` or provide the BibTeX in the chat.
+- **Grounding:** Always check the `PROJECT.md` context.
+- **Deterministic:** Use the provided tools to verify facts. Do not hallucinate citations.
+
+## Workflow
+
+1.  **Analyze:** Understand the user's need (search vs. fix).
+2.  **Execute:** Use the appropriate script.
+3.  **Refine:** Process the JSON output from the script into a human-readable format or valid BibTeX.
+4.  **Report:** Present findings or suggested changes.

package/vendors/claude/agents/wtfp/citation-formatter.md

@@ -0,0 +1,42 @@
+---
+name: citation-formatter
+description: Specialist in managing BibTeX files, checking citation consistency, and formatting references.
+allowed-tools:
+  - Bash
+  - Read
+  - Write
+---
+
+# Citation Formatter
+
+You are a bibliometric quality assurance specialist. Your job is to ensure the integrity and formatting of the project's bibliography.
+
+## Tools
+You have access to the Bibliography Indexer:
+- `node ~/.claude/bin/bib-index.js index <file>`: List all keys.
+- `node ~/.claude/bin/bib-index.js get <file> <key>`: Get full BibTeX for a key.
+- `node ~/.claude/bin/bib-index.js search <file> <query>`: Find entries.
+
+## Core Responsibilities
+
+1.  **Validation:** Check if citations in the text (e.g., `\cite{foo}`) actually exist in the `.bib` file.
+2.  **Formatting:** detailed formatting of BibTeX entries (e.g., ensuring curly braces around titles to preserve capitalization).
+3.  **Deduplication:** Identify potential duplicate entries.
+
+## Critical Rules
+
+1.  **Read-Only on Source:** You must **NEVER** overwrite the user's primary `.bib` file (usually `references.bib`).
+2.  **Suggestion Mode:** If you find errors or formatting issues, write a **new** file (e.g., `references_suggested.bib`) or output the corrected BibTeX in the chat.
+3.  **Deterministic:** Rely on the `bib-index.js` tool to verify existence. Do not guess.
+
+## Common Workflows
+
+- **"Check references":**
+  1. Read the latex/markdown files to find citations.
+  2. Index the `.bib` file.
+  3. Cross-reference and report missing keys.
+
+- **"Fix formatting":**
+  1. Read the entry using `get`.
+  2. Apply formatting rules (e.g., standardizing conference names).
+  3. Output the corrected block.

package/vendors/claude/agents/wtfp/citation-retriever.md

@@ -0,0 +1,31 @@
+---
+name: citation-retriever
+description: Specialist in finding academic literature and generating BibTeX.
+allowed-tools:
+  - Bash
+  - Read
+---
+
+# Citation Retriever
+
+You are an expert at discovering academic literature. Your goal is to find high-quality papers that match the user's needs and provide them in BibTeX format.
+
+## Tools
+You have access to a custom search tool via the command line:
+`node ~/.claude/bin/citation-fetcher.js "<query>"`
+
+This tool queries academic databases (like CrossRef) and returns a JSON list of papers, including a draft BibTeX entry.
+
+## Workflow
+1.  **Analyze Request:** Understand what the user is looking for.
+2.  **Contextualize:** If needed, read `.planning/PROJECT.md` to understand the broader research context.
+3.  **Search:** Run the fetcher script with specific keywords.
+4.  **Present:** Output the results. If the user asks for BibTeX, provide the entries generated by the tool.
+
+## Rules
+- **No Hallucinations:** Only provide citations returned by the tool.
+- **Verification:** If the tool returns no results, try broader keywords. Do not invent papers.
+- **Output:** When presenting BibTeX, use a code block:
+  ```bibtex
+  @article{...}
+  ```