wtf-p 0.1.0 → 0.3.0

package/bin/lib/utils.js

@@ -0,0 +1,338 @@
+/**
+ * Shared utilities for WTF-P CLI
+ */
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const readline = require('readline');
+
+// Version tracking file name
+const VERSION_FILE = '.wtfp-version';
+
+// ============ Path Utilities ============
+
+/**
+ * Expand ~ to home directory
+ */
+function expandTilde(filePath) {
+  if (filePath && filePath.startsWith('~/')) {
+    return path.join(os.homedir(), filePath.slice(2));
+  }
+  return filePath;
+}
+
+/**
+ * Normalize path: expand tilde, resolve to absolute, resolve symlinks
+ */
+function normalizePath(inputPath) {
+  if (!inputPath) return inputPath;
+
+  // Expand tilde
+  let normalized = expandTilde(inputPath);
+
+  // Resolve to absolute path
+  normalized = path.resolve(normalized);
+
+  // Resolve symlinks if path exists
+  if (fs.existsSync(normalized)) {
+    try {
+      normalized = fs.realpathSync(normalized);
+    } catch {
+      // Keep as-is if realpath fails (permissions, etc.)
+    }
+  }
+
+  return normalized;
+}
+
+/**
+ * Validate path for safety
+ */
+function isValidPath(inputPath) {
+  if (!inputPath || typeof inputPath !== 'string') return false;
+
+  // Check for null bytes (security issue)
+  if (inputPath.includes('\0')) return false;
+
+  // Check path length (Windows ~260, but we use 1024 for safety)
+  if (inputPath.length > 1024) return false;
+
+  return true;
+}
+
+/**
+ * Get the configuration directory for a specific vendor
+ */
+function getVendorDir(vendor, explicitConfigDir, isGlobal = true) {
+  if (!isGlobal) {
+    return path.join(process.cwd(), `.${vendor}`);
+  }
+
+  const envVar = `${vendor.toUpperCase()}_CONFIG_DIR`;
+  const configDir = normalizePath(explicitConfigDir) ||
+                   normalizePath(process.env[envVar]);
+
+  return configDir || path.join(os.homedir(), `.${vendor}`);
+}
+
+/**
+ * Get the Claude config directory (respects CLAUDE_CONFIG_DIR env var)
+ */
+function getClaudeDir(explicitConfigDir, isGlobal = true) {
+  return getVendorDir('claude', explicitConfigDir, isGlobal);
+}
+
+/**
+ * Get human-readable label for a path (with ~ for homedir)
+ */
+function getPathLabel(fullPath, isGlobal = true) {
+  if (isGlobal) {
+    return fullPath.replace(os.homedir(), '~');
+  }
+  return fullPath.replace(process.cwd(), '.');
+}
+
+// ============ Version Tracking ============
+
+/**
+ * Read installed WTF-P version from .wtfp-version file
+ */
+function readInstalledVersion(claudeDir) {
+  const versionFile = path.join(claudeDir, VERSION_FILE);
+  if (!fs.existsSync(versionFile)) {
+    return null;
+  }
+  try {
+    const content = fs.readFileSync(versionFile, 'utf8').trim();
+    const data = JSON.parse(content);
+    return data;
+  } catch {
+    // Corrupt file or old format
+    return { version: 'unknown', corrupt: true };
+  }
+}
+
+/**
+ * Write version tracking file
+ */
+function writeVersionFile(claudeDir, version, installedFiles) {
+  if (!fs.existsSync(claudeDir)) {
+    fs.mkdirSync(claudeDir, { recursive: true });
+  }
+  const versionFile = path.join(claudeDir, VERSION_FILE);
+  const data = {
+    version,
+    installedAt: new Date().toISOString(),
+    files: installedFiles.length,
+    manifest: installedFiles.map(f => ({
+      path: f.dest.replace(claudeDir, '.'),
+      checksum: simpleChecksum(f.dest)
+    }))
+  };
+  fs.writeFileSync(versionFile, JSON.stringify(data, null, 2));
+}
+
+/**
+ * Simple checksum for file integrity (not cryptographic)
+ */
+function simpleChecksum(filePath) {
+  if (!fs.existsSync(filePath)) return null;
+  try {
+    const content = fs.readFileSync(filePath, 'utf8');
+    let hash = 0;
+    for (let i = 0; i < content.length; i++) {
+      const char = content.charCodeAt(i);
+      hash = ((hash << 5) - hash) + char;
+      hash = hash & hash; // Convert to 32bit integer
+    }
+    return hash.toString(16);
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Detect installation state
+ */
+function detectInstallation(vendorDir) {
+  const result = {
+    hasCommands: false,
+    hasWorkflows: false,
+    hasSkills: false,
+    version: null,
+    partial: false,
+    corrupt: false,
+    commandFiles: [],
+    workflowFiles: [],
+    skillFiles: []
+  };
+
+  const commandsDir = path.join(vendorDir, 'commands', 'wtfp');
+  const workflowsDir = path.join(vendorDir, 'write-the-f-paper');
+  const skillsDir = path.join(vendorDir, 'skills', 'wtfp');
+
+  result.hasCommands = fs.existsSync(commandsDir);
+  result.hasWorkflows = fs.existsSync(workflowsDir);
+  result.hasSkills = fs.existsSync(skillsDir);
+
+  if (result.hasCommands) {
+    result.commandFiles = collectFiles(commandsDir);
+  }
+  if (result.hasWorkflows) {
+    result.workflowFiles = collectFiles(workflowsDir);
+  }
+  if (result.hasSkills) {
+    result.skillFiles = collectFiles(skillsDir);
+  }
+
+  // Read version info
+  const versionData = readInstalledVersion(vendorDir);
+  if (versionData) {
+    result.version = versionData.version;
+    result.corrupt = versionData.corrupt || false;
+
+    // Check for partial install
+    if (!versionData.corrupt) {
+      const expectedHasCommands = versionData.manifest?.some(f => f.path.includes('commands/wtfp'));
+      const expectedHasWorkflows = versionData.manifest?.some(f => f.path.includes('write-the-f-paper'));
+      const expectedHasSkills = versionData.manifest?.some(f => f.path.includes('skills/wtfp'));
+
+      if ((expectedHasCommands && !result.hasCommands) ||
+          (expectedHasWorkflows && !result.hasWorkflows) ||
+          (expectedHasSkills && !result.hasSkills)) {
+        result.partial = true;
+      }
+    }
+  } else if (result.hasCommands || result.hasWorkflows || result.hasSkills) {
+    // Files exist but no version file - legacy install
+    result.version = 'legacy';
+  }
+
+  return result;
+}
+
+/**
+ * Collect all files recursively in a directory
+ */
+function collectFiles(dir, files = []) {
+  if (!fs.existsSync(dir)) return files;
+
+  const entries = fs.readdirSync(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    const fullPath = path.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      collectFiles(fullPath, files);
+    } else {
+      files.push(fullPath);
+    }
+  }
+  return files;
+}
+
+// ============ Output Utilities ============
+
+/**
+ * Create color functions (respects --no-color)
+ */
+function createColors(useColors = true) {
+  if (!useColors) {
+    return {
+      cyan: s => s,
+      green: s => s,
+      yellow: s => s,
+      red: s => s,
+      magenta: s => s,
+      dim: s => s,
+      reset: ''
+    };
+  }
+
+  return {
+    cyan: s => `\x1b[36m${s}\x1b[0m`,
+    green: s => `\x1b[32m${s}\x1b[0m`,
+    yellow: s => `\x1b[33m${s}\x1b[0m`,
+    red: s => `\x1b[31m${s}\x1b[0m`,
+    magenta: s => `\x1b[35m${s}\x1b[0m`,
+    dim: s => `\x1b[2m${s}\x1b[0m`,
+    reset: '\x1b[0m'
+  };
+}
+
+/**
+ * Create output helpers (respects --quiet/--verbose)
+ */
+function createOutput(options = {}) {
+  const { quiet = false, verbose = false, useColors = true } = options;
+  const c = createColors(useColors);
+
+  return {
+    colors: c,
+    log: (...args) => !quiet && console.log(...args),
+    verbose: (...args) => verbose && !quiet && console.log(c.dim(...args)),
+    error: (...args) => console.error(c.red('Error:'), ...args),
+    warn: (...args) => !quiet && console.log(c.yellow('Warning:'), ...args),
+    success: (...args) => !quiet && console.log(c.green('✓'), ...args),
+    info: (...args) => !quiet && console.log(c.cyan('ℹ'), ...args)
+  };
+}
+
+// ============ Prompt Utilities ============
+
+/**
+ * Create readline interface
+ */
+function createRL() {
+  return readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+}
+
+/**
+ * Prompt user with a question
+ */
+function prompt(rl, question) {
+  return new Promise(resolve => {
+    rl.question(question, answer => resolve(answer.trim().toLowerCase()));
+  });
+}
+
+/**
+ * Generate backup path with timestamp
+ */
+function getBackupPath(filePath) {
+  const timestamp = new Date().toISOString().replace(/[:.]/g, '-').slice(0, 19);
+  const dir = path.dirname(filePath);
+  const ext = path.extname(filePath);
+  const base = path.basename(filePath, ext);
+  return path.join(dir, `${base}.backup-${timestamp}${ext}`);
+}
+
+// ============ Exports ============
+
+module.exports = {
+  // Path utilities
+  expandTilde,
+  normalizePath,
+  isValidPath,
+  getClaudeDir,
+  getPathLabel,
+
+  // Version tracking
+  VERSION_FILE,
+  readInstalledVersion,
+  writeVersionFile,
+  simpleChecksum,
+  detectInstallation,
+  collectFiles,
+
+  // Output utilities
+  createColors,
+  createOutput,
+
+  // Prompt utilities
+  createRL,
+  prompt,
+  getBackupPath
+};

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