specmem-hardwicksoftware 3.5.99

package/claude-hooks/grammar-engine.cjs

@@ -0,0 +1,159 @@
+#!/usr/bin/env node
+/**
+ * ENGLISH GRAMMAR ENGINE
+ * ======================
+ * Handles ALL English morphology for perfect suffix extraction
+ */
+
+// Suffix patterns ordered by specificity (longest first)
+const SUFFIX_RULES = [
+  // -ization/-isation (organization → organize)
+  { suffix: 'ization', base: (w) => w + 'ize' },
+  { suffix: 'isation', base: (w) => w + 'ise' },
+
+  // -ation (creation → create)
+  { suffix: 'ation', base: (w) => w + 'ate', altBase: (w) => w + 'e' },
+
+  // -tion (addition → add)
+  { suffix: 'tion', base: (w) => w.endsWith('c') ? w + 't' : w },
+
+  // -sion (permission → permit, expansion → expand)
+  { suffix: 'sion', base: (w) => w + 'd', altBase: (w) => w + 't' },
+
+  // -ment (improvement → improve)
+  { suffix: 'ment', base: (w) => w, altBase: (w) => w + 'e' },
+
+  // -ness (happiness → happy, sadness → sad)
+  { suffix: 'ness', base: (w) => w.endsWith('i') ? w.slice(0,-1) + 'y' : w },
+
+  // -able/-ible (readable → read, visible → ?)
+  { suffix: 'able', base: (w) => w, altBase: (w) => w + 'e' },
+  { suffix: 'ible', base: (w) => w },
+
+  // -ally (automatically → automatic)
+  { suffix: 'ally', base: (w) => w + 'al', outSuffix: 'ally' },
+
+  // -ily (happily → happy)
+  { suffix: 'ily', base: (w) => w + 'y', outSuffix: 'ly' },
+
+  // -ly (quickly → quick)
+  { suffix: 'ly', base: (w) => w },
+
+  // -ful/-less (helpful → help)
+  { suffix: 'ful', base: (w) => w },
+  { suffix: 'less', base: (w) => w },
+
+  // -ous (famous → fame, dangerous → danger)
+  { suffix: 'ous', base: (w) => w, altBase: (w) => w + 'e' },
+
+  // -ive (creative → create, active → act)
+  { suffix: 'ive', base: (w) => w, altBase: (w) => w + 'e' },
+
+  // -ing (working → work, running → run, creating → create)
+  {
+    suffix: 'ing',
+    base: (w) => w,
+    altBase: (w) => w + 'e',  // creating → create
+    altBase2: (w) => w.length > 1 && w[w.length-1] === w[w.length-2] ? w.slice(0,-1) : null // running → run
+  },
+
+  // -ed (worked → work, stopped → stop, created → create)
+  {
+    suffix: 'ed',
+    base: (w) => w,
+    altBase: (w) => w + 'e',  // created → create (actually creat+ed, base+e)
+    altBase2: (w) => w.length > 1 && w[w.length-1] === w[w.length-2] ? w.slice(0,-1) : null, // stopped → stop
+    altBase3: (w) => w.endsWith('i') ? w.slice(0,-1) + 'y' : null  // cried → cry
+  },
+
+  // -er (worker → work, bigger → big, writer → write)
+  {
+    suffix: 'er',
+    base: (w) => w,
+    altBase: (w) => w + 'e',
+    altBase2: (w) => w.length > 1 && w[w.length-1] === w[w.length-2] ? w.slice(0,-1) : null
+  },
+
+  // -est (biggest → big, fastest → fast)
+  {
+    suffix: 'est',
+    base: (w) => w,
+    altBase: (w) => w.length > 1 && w[w.length-1] === w[w.length-2] ? w.slice(0,-1) : null
+  },
+
+  // -ies → -y (cries → cry, flies → fly)
+  { suffix: 'ies', base: (w) => w + 'y', outSuffix: 's' },
+
+  // -es (watches → watch, boxes → box)
+  { suffix: 'es', base: (w) => w, altBase: (w) => w + 'e', outSuffix: 's' },
+
+  // -'s (possessive)
+  { suffix: "'s", base: (w) => w },
+
+  // -s (works → work)
+  { suffix: 's', base: (w) => w },
+];
+
+/**
+ * Extract base form and suffix using grammar rules
+ * @param {string} word - The inflected word
+ * @param {Object} CODES - Dictionary to check base forms against
+ * @returns {{base: string, suffix: string}}
+ */
+function extractWithGrammar(word, CODES) {
+  const lower = word.toLowerCase();
+
+  for (const rule of SUFFIX_RULES) {
+    if (!lower.endsWith(rule.suffix)) continue;
+    if (lower.length <= rule.suffix.length + 2) continue;
+
+    const stem = lower.slice(0, -rule.suffix.length);
+    const outSuffix = rule.outSuffix || rule.suffix;
+
+    // Try all base form transformations
+    const tries = [
+      rule.base(stem),
+      rule.altBase?.(stem),
+      rule.altBase2?.(stem),
+      rule.altBase3?.(stem),
+    ].filter(Boolean);
+
+    for (const tryBase of tries) {
+      if (CODES.hasOwnProperty(tryBase)) {
+        return { base: tryBase, suffix: outSuffix };
+      }
+    }
+  }
+
+  return { base: word, suffix: '' };
+}
+
+// Export
+module.exports = { extractWithGrammar, SUFFIX_RULES };
+
+// Test if run directly
+if (require.main === module) {
+  const CODES = require('./merged-codes.cjs');
+
+  const tests = [
+    'working', 'worked', 'worker', 'works',
+    'running', 'ran', 'runs',
+    'creating', 'created', 'creates', 'creation',
+    'happiness', 'happily',
+    'improvement', 'improving',
+    'automatically', 'automatic',
+    'readable', 'reading',
+    'stopped', 'stopping',
+    'cried', 'cries', 'crying',
+    'bigger', 'biggest',
+    'watched', 'watches', 'watching',
+  ];
+
+  console.log('Grammar Engine Tests:\n');
+  for (const t of tests) {
+    const { base, suffix } = extractWithGrammar(t, CODES);
+    const code = CODES[base] || '?';
+    const result = suffix ? `${code}${suffix}` : code;
+    console.log(`${t.padEnd(15)} → ${base.padEnd(10)} + ${suffix.padEnd(5)} = ${result}`);
+  }
+}

package/claude-hooks/input-aware-improver.js

@@ -0,0 +1,231 @@
+#!/usr/bin/env node
+/**
+ * Input-Aware Auto-Improver
+ * - Pauses during user typing
+ * - Captures user input (handles backspaces)
+ * - Only fires auto-improve when user is idle
+ * - Feeds captured input to 
+ *
+ * Works in standalone mode (no PM2 required)
+ */
+
+const fs = require('fs');
+const http = require('http');
+const path = require('path');
+const specmemPaths = require('./specmem-paths.cjs');
+
+const SPECMEM_HOME = specmemPaths.getSpecmemHome();
+const SPECMEM_PKG = specmemPaths.getSpecmemPkg();
+// Per-project sockets: default to {cwd}/specmem/sockets/
+const SPECMEM_RUN_DIR = specmemPaths.expandCwd(process.env.SPECMEM_RUN_DIR) || specmemPaths.getProjectSocketDir();
+const SPECMEM_EMBEDDING_SOCKET = specmemPaths.expandCwd(process.env.SPECMEM_EMBEDDING_SOCKET);
+const SPECMEM_PROJECT_PATH = specmemPaths.expandCwd(process.env.SPECMEM_PROJECT_PATH);
+const projectFilterEnabled = process.env.SPECMEM_PROJECT_FILTER !== 'false'; // defaults to TRUE
+
+// Use project-scoped path for state file
+const STATE_FILE = path.join(SPECMEM_RUN_DIR, 'claude-input-state.json');
+
+// ============================================================================
+// Dynamic Password Loading (matches src/config/password.ts)
+// ============================================================================
+
+function getPassword() {
+  // 1. Check unified env var first (recommended)
+  const unified = process.env.SPECMEM_PASSWORD;
+  if (unified) return unified;
+
+  // 2. Fall back to legacy dashboard password
+  const dashboard = process.env.SPECMEM_DASHBOARD_PASSWORD;
+  if (dashboard) return dashboard;
+
+  // 3. Fall back to legacy API password
+  const api = process.env.SPECMEM_API_PASSWORD;
+  if (api) return api;
+
+  // 4. Try to read from .env files
+  const envFiles = [
+    path.join(SPECMEM_HOME, '.env'),
+    path.join(SPECMEM_HOME, 'specmem.env'),
+    path.join(process.env.HOME || '/root', '.specmem/.env')
+  ];
+
+  const passwordVarNames = [
+    'SPECMEM_PASSWORD',
+    'SPECMEM_DASHBOARD_PASSWORD',
+    'SPECMEM_API_PASSWORD'
+  ];
+
+  for (const envPath of envFiles) {
+    try {
+      if (fs.existsSync(envPath)) {
+        const content = fs.readFileSync(envPath, 'utf-8');
+        for (const varName of passwordVarNames) {
+          const pattern = new RegExp(`${varName}=(.+)`);
+          const match = content.match(pattern);
+          if (match) {
+            return match[1].trim().replace(/^["']|["']$/g, '');
+          }
+        }
+      }
+    } catch (e) {
+      // Continue to next file
+    }
+  }
+
+  // 5. Default fallback
+  return 'specmem';
+}
+
+const SPECMEM_HOST = process.env.SPECMEM_HOST || 'localhost';
+const SPECMEM_PORT = process.env.SPECMEM_DASHBOARD_PORT || '8595';
+const SPECMEM_API = `http://${SPECMEM_HOST}:${SPECMEM_PORT}/api`;
+const SPECMEM_PASSWORD = getPassword();
+
+// Typing detection - if input changed recently, user is typing
+const TYPING_COOLDOWN_MS = 2000; // Wait 2s after last keystroke
+
+function getState() {
+    try {
+        if (fs.existsSync(STATE_FILE)) {
+            return JSON.parse(fs.readFileSync(STATE_FILE, 'utf8'));
+        }
+    } catch {}
+    return { lastInput: '', lastInputTime: 0, buffer: '' };
+}
+
+function saveState(state) {
+    try {
+        fs.writeFileSync(STATE_FILE, JSON.stringify(state));
+    } catch {}
+}
+
+// Process input buffer - handle backspaces
+function processBuffer(raw) {
+    let result = '';
+    for (const char of raw) {
+        if (char === '\b' || char === '\x7f') { // Backspace
+            result = result.slice(0, -1);
+        } else if (char >= ' ' || char === '\n' || char === '\t') {
+            result += char;
+        }
+    }
+    return result.trim();
+}
+
+// Check if user is currently typing
+function isUserTyping(state, currentInput) {
+    const now = Date.now();
+    const inputChanged = currentInput !== state.lastInput;
+
+    if (inputChanged) {
+        // User typed something - update state and signal typing
+        state.lastInput = currentInput;
+        state.lastInputTime = now;
+        state.buffer = processBuffer(currentInput);
+        saveState(state);
+        return true;
+    }
+
+    // Check if within cooldown period
+    const timeSinceLastInput = now - state.lastInputTime;
+    return timeSinceLastInput < TYPING_COOLDOWN_MS;
+}
+
+// Get recent memories for context
+async function getRecentContext(limit = 3) {
+    return new Promise((resolve) => {
+        const req = http.request(`${SPECMEM_API}/memories?limit=${limit}&orderBy=created&orderDirection=desc`, {
+            method: 'GET',
+            headers: { 'Authorization': `Bearer ${SPECMEM_PASSWORD}` },
+            timeout: 2000
+        }, (res) => {
+            let body = '';
+            res.on('data', chunk => body += chunk);
+            res.on('end', () => {
+                try {
+                    resolve(JSON.parse(body).memories || []);
+                } catch { resolve([]); }
+            });
+        });
+        req.on('error', () => resolve([]));
+        req.on('timeout', () => { req.destroy(); resolve([]); });
+        req.end();
+    });
+}
+
+/**
+ * Read stdin with timeout to prevent indefinite hangs
+ * CRIT-07 FIX: All hooks must use this instead of raw for-await
+ */
+function readStdinWithTimeout(timeoutMs = 5000) {
+  return new Promise((resolve) => {
+    let input = '';
+    const timer = setTimeout(() => {
+      process.stdin.destroy();
+      resolve(input);
+    }, timeoutMs);
+
+    process.stdin.setEncoding('utf8');
+    process.stdin.on('data', (chunk) => { input += chunk; });
+    process.stdin.on('end', () => {
+      clearTimeout(timer);
+      resolve(input);
+    });
+    process.stdin.on('error', () => {
+      clearTimeout(timer);
+      resolve(input);
+    });
+  });
+}
+
+async function main() {
+    // CRIT-07 FIX: Read input with timeout instead of indefinite for-await
+    let input = await readStdinWithTimeout(5000);
+
+    try {
+        const hookData = JSON.parse(input);
+        const prompt = hookData.prompt || '';
+        const state = getState();
+
+        // If user is typing, just passthrough - don't inject anything
+        if (isUserTyping(state, prompt)) {
+            // Silent passthrough - let user type
+            process.exit(0);
+        }
+
+        // User stopped typing - check if we should auto-improve
+        const capturedInput = state.buffer || prompt;
+
+        // Only inject context if prompt has improvement keywords OR is a question
+        const shouldEnhance = /fix|improve|suggest|cook|self.?improve|specmem|\?$/i.test(capturedInput);
+
+        if (!shouldEnhance) {
+            process.exit(0);
+        }
+
+        // Get recent context from specmem
+        const memories = await getRecentContext(3);
+        let context = '';
+
+        if (memories.length > 0) {
+            const memContext = memories.map((m, i) => {
+                const preview = (m.content || '').substring(0, 150).replace(/\n/g, ' ');
+                return `${i+1}. ${preview}...`;
+            }).join('\n');
+            context = `[RECENT CONTEXT]\n${memContext}\n`;
+        }
+
+        context += `\n[AUTO-IMPROVE ACTIVE] Pick best option, execute fully.`;
+
+        console.log(JSON.stringify({ type: 'context', context }));
+
+    } catch (e) {
+        // LOW-44 FIX: Log errors before exit instead of silent fail
+        console.error('[input-aware-improver] Error:', e.message || e);
+    }
+}
+
+main().catch((e) => {
+    console.error('[input-aware-improver] Unhandled error:', e.message || e);
+    process.exit(0);
+});

package/claude-hooks/is-agent.cjs

@@ -0,0 +1,64 @@
+#!/usr/bin/env node
+/**
+ * SHARED AGENT DETECTION UTILITY
+ *
+ * Use this in any hook that should ONLY run for agents, not main .
+ *
+ * Usage:
+ *   const { isAgent } = require('./is-agent.cjs');
+ *   if (!isAgent()) process.exit(0); // Skip for main 
+ */
+
+/**
+ * Detect if current process is an agent (not main )
+ *
+ * IMPORTANT: Only explicit agent indicators count!
+ * Screen sessions (STY) and process trees are NOT reliable because
+ * main  also runs in screen sessions via specmem-init.
+ */
+function isAgent() {
+  // ONLY use explicit env vars set by agent spawning code
+  // These are set by deployTeamMember or Task tool when spawning agents
+  if (process.env.SPECMEM_AGENT_MODE === '1') return true;
+  if (process.env.SPECMEM_TEAM_MEMBER_ID) return true;
+  if (process.env.CLAUDE_SUBAGENT === '1') return true;
+  if (process.env.CLAUDE_AGENT_ID) return true;
+
+  // Check if this is a team member screen session (has specmem-tm- prefix)
+  // Regular  screens are claude-<project>, not specmem-tm-
+  if (process.env.STY && process.env.STY.includes('specmem-tm-')) return true;
+
+  // Check working directory for agent-specific paths
+  try {
+    const cwd = process.cwd();
+    // Only agent scratchpads, not main project
+    if (cwd.includes('/tmp/claude/') && cwd.includes('/scratchpad/')) {
+      return true;
+    }
+  } catch (e) {}
+
+  // Default: NOT an agent (main  session gets unrestricted access)
+  return false;
+}
+
+/**
+ * Check if we're in a subagent context (Task tool spawned)
+ */
+function isSubagent() {
+  return process.env.CLAUDE_SUBAGENT === '1' ||
+         process.env.CLAUDE_AGENT_ID !== undefined;
+}
+
+/**
+ * Check if we're a deployed team member (specmem team member system)
+ */
+function isTeamMember() {
+  return process.env.SPECMEM_TEAM_MEMBER_ID !== undefined ||
+         (process.env.STY && process.env.STY.includes('specmem-tm-'));
+}
+
+module.exports = {
+  isAgent,
+  isSubagent,
+  isTeamMember
+};

package/claude-hooks/mega-test.cjs

@@ -0,0 +1,213 @@
+#!/usr/bin/env node
+/**
+ * MEGA TEST SUITE FOR TOKEN COMPRESSOR
+ * Tests real code, real sentences, and edge cases
+ */
+
+const c = require('./token-compressor.cjs');
+
+let passed = 0, failed = 0;
+const failures = [];
+
+function test(input, expectRoundTrip = true) {
+  const comp = c.compress(input);
+  const decomp = c.decompress(comp);
+  const ok = decomp === input;
+
+  if (ok) {
+    passed++;
+    const savings = ((1 - comp.length / input.length) * 100).toFixed(0);
+    console.log(`✓ ${savings}%: "${input.slice(0,50)}${input.length>50?'...':''}" → ${comp.length} chars`);
+  } else {
+    failed++;
+    failures.push({ input, comp, decomp });
+    console.log(`✗ FAIL: "${input.slice(0,40)}..."`);
+    console.log(`  comp: ${comp}`);
+    console.log(`  got:  ${decomp}`);
+  }
+  return ok;
+}
+
+console.log('═══════════════════════════════════════════════════════════════');
+console.log('                    MEGA TOKEN COMPRESSOR TEST');
+console.log('═══════════════════════════════════════════════════════════════\n');
+
+// ═══════════════════════════════════════════════════════════════════════════
+// PART 1: SINGLE WORDS - Base forms
+// ═══════════════════════════════════════════════════════════════════════════
+console.log('─── SINGLE WORDS (Base Forms) ───');
+const baseWords = [
+  'function', 'variable', 'parameter', 'return', 'class', 'object', 'array',
+  'string', 'number', 'boolean', 'value', 'method', 'property', 'interface',
+  'module', 'package', 'library', 'framework', 'error', 'exception', 'warning',
+  'debug', 'memory', 'buffer', 'stack', 'heap', 'queue', 'callback', 'promise',
+  'create', 'read', 'update', 'delete', 'add', 'remove', 'insert', 'find',
+  'search', 'filter', 'sort', 'parse', 'validate', 'check', 'test', 'verify',
+  'server', 'client', 'database', 'cache', 'file', 'directory', 'path',
+  'request', 'response', 'query', 'session', 'token', 'user', 'permission'
+];
+for (const w of baseWords) test(w);
+
+// ═══════════════════════════════════════════════════════════════════════════
+// PART 2: INFLECTED FORMS - Plurals, Past Tense, Present Participle
+// ═══════════════════════════════════════════════════════════════════════════
+console.log('\n─── INFLECTED FORMS ───');
+const inflected = [
+  // Plurals
+  'functions', 'variables', 'parameters', 'classes', 'objects', 'arrays',
+  'errors', 'exceptions', 'warnings', 'servers', 'clients', 'databases',
+  'files', 'queries', 'sessions', 'tokens', 'users', 'permissions', 'settings',
+  // Past tense
+  'created', 'updated', 'deleted', 'added', 'removed', 'inserted', 'found',
+  'searched', 'filtered', 'sorted', 'parsed', 'validated', 'checked', 'tested',
+  'connected', 'disconnected', 'started', 'stopped', 'executed', 'called',
+  // Present participle
+  'creating', 'reading', 'updating', 'deleting', 'adding', 'removing',
+  'searching', 'filtering', 'sorting', 'parsing', 'validating', 'checking',
+  'connecting', 'starting', 'stopping', 'running', 'building', 'working',
+  // Comparatives
+  'bigger', 'smaller', 'faster', 'slower', 'higher', 'lower',
+  // Superlatives
+  'biggest', 'smallest', 'fastest', 'slowest', 'highest', 'lowest'
+];
+for (const w of inflected) test(w);
+
+// ═══════════════════════════════════════════════════════════════════════════
+// PART 3: REAL SENTENCES
+// ═══════════════════════════════════════════════════════════════════════════
+console.log('\n─── REAL SENTENCES ───');
+const sentences = [
+  'The function returns a value from the database.',
+  'User authentication failed due to invalid credentials.',
+  'The server is processing multiple client requests.',
+  'Creating a new component with custom properties.',
+  'The query returned empty results from the cache.',
+  'Checking if the session token is still valid.',
+  'The application crashed with a memory exception.',
+  'Building the project with optimized settings.',
+  'The worker is busy processing background tasks.',
+  'Database connection timeout exceeded the limit.',
+  'Parsing JSON response from the API endpoint.',
+  'The callback function was triggered successfully.',
+  'Searching for files matching the pattern.',
+  'Validating user input before submission.',
+  'The promise resolved with success status.',
+];
+for (const s of sentences) test(s);
+
+// ═══════════════════════════════════════════════════════════════════════════
+// PART 4: ACTUAL CODE SNIPPETS
+// ═══════════════════════════════════════════════════════════════════════════
+console.log('\n─── ACTUAL CODE SNIPPETS ───');
+const codeSnippets = [
+  'function getData() { return fetch(url); }',
+  'const user = await database.findOne({ id: userId });',
+  'if (error) { console.log(error.message); }',
+  'const filtered = array.filter(item => item.active);',
+  'export default class UserComponent extends React.Component {}',
+  'const config = { server: "localhost", port: 3000 };',
+  'try { await client.connect(); } catch (error) { }',
+  'const result = users.map(user => user.name);',
+  'async function processQueue() { while (true) {} }',
+  'const { data, loading, error } = useQuery(GET_USERS);',
+];
+for (const code of codeSnippets) test(code);
+
+// ═══════════════════════════════════════════════════════════════════════════
+// PART 5: MULTI-LINE CODE BLOCKS
+// ═══════════════════════════════════════════════════════════════════════════
+console.log('\n─── MULTI-LINE CODE BLOCKS ───');
+
+const multiLine1 = `
+async function fetchUserData(userId) {
+  const response = await fetch('/api/users/' + userId);
+  const data = await response.json();
+  return data;
+}
+`.trim();
+test(multiLine1);
+
+const multiLine2 = `
+class DatabaseConnection {
+  constructor(config) {
+    this.config = config;
+    this.connected = false;
+  }
+
+  async connect() {
+    this.connected = true;
+  }
+}
+`.trim();
+test(multiLine2);
+
+const multiLine3 = `
+const settings = {
+  database: { host: 'localhost', port: 5432 },
+  cache: { enabled: true, timeout: 3600 },
+  server: { port: 3000, debug: false }
+};
+`.trim();
+test(multiLine3);
+
+// ═══════════════════════════════════════════════════════════════════════════
+// PART 6: EDGE CASES
+// ═══════════════════════════════════════════════════════════════════════════
+console.log('\n─── EDGE CASES ───');
+const edgeCases = [
+  // Irregular verbs
+  'written', 'ran', 'built', 'sent', 'found',
+  // Words that look like inflections but aren't
+  'string', 'setting', 'coding', 'testing',
+  // Short words
+  'id', 'db', 'ui', 'api',
+  // Mixed case (should preserve original)
+  'JavaScript', 'TypeScript', 'NodeJS',
+  // With punctuation
+  'error!', 'success?', '(function)',
+  // Contractions
+  "isn't", "doesn't", "can't",
+];
+for (const e of edgeCases) test(e);
+
+// ═══════════════════════════════════════════════════════════════════════════
+// RESULTS
+// ═══════════════════════════════════════════════════════════════════════════
+console.log('\n═══════════════════════════════════════════════════════════════');
+console.log('                         RESULTS');
+console.log('═══════════════════════════════════════════════════════════════');
+const accuracy = ((passed / (passed + failed)) * 100).toFixed(1);
+console.log(`\nPassed: ${passed}`);
+console.log(`Failed: ${failed}`);
+console.log(`Accuracy: ${accuracy}%`);
+
+if (failures.length > 0) {
+  console.log('\n─── FAILURES ───');
+  for (const f of failures) {
+    console.log(`\nInput:  "${f.input}"`);
+    console.log(`Comp:   "${f.comp}"`);
+    console.log(`Got:    "${f.decomp}"`);
+  }
+}
+
+// Calculate compression stats on a sample text
+console.log('\n─── COMPRESSION EFFICIENCY ───');
+const sampleText = `
+The server function processes database queries and returns cached responses.
+User authentication validates the session token and checks permissions.
+The component renders the filtered data with custom styling.
+Error handling catches exceptions and logs warning messages.
+Asynchronous callbacks trigger when the promise resolves successfully.
+`.trim();
+
+const compressed = c.compress(sampleText);
+const decompressed = c.decompress(compressed);
+const roundTripOk = decompressed === sampleText;
+const charSavings = ((1 - compressed.length / sampleText.length) * 100).toFixed(1);
+
+console.log(`Original:    ${sampleText.length} chars`);
+console.log(`Compressed:  ${compressed.length} chars`);
+console.log(`Savings:     ${charSavings}%`);
+console.log(`Round-trip:  ${roundTripOk ? '✓ PERFECT' : '✗ FAILED'}`);
+
+process.exit(failed > 0 ? 1 : 0);