50c 2.2.0 → 2.5.0

package/lib/packs/beacon.js

@@ -46,6 +46,22 @@ async function learningStats() {
   return apiRequest('GET', '/tools/learning_stats');
 }
 
+async function roadmapAdd(idea, priority = 'medium', tags = []) {
+  return apiRequest('POST', '/tools/roadmap', { action: 'add', idea, priority, tags });
+}
+
+async function roadmapList(filter = null) {
+  return apiRequest('POST', '/tools/roadmap', { action: 'list', filter });
+}
+
+async function roadmapUpdate(id, updates) {
+  return apiRequest('POST', '/tools/roadmap', { action: 'update', id, ...updates });
+}
+
+async function roadmapDelete(id) {
+  return apiRequest('POST', '/tools/roadmap', { action: 'delete', id });
+}
+
 // Tool definitions - STARTER tier ($29/mo)
 const BEACON_TOOLS = [
   {
@@ -173,6 +189,62 @@ const BEACON_TOOLS = [
     inputSchema: { type: 'object', properties: {} },
     cost: 0,
     tier: 'free'
+  },
+  {
+    name: 'roadmap_add',
+    description: 'Add idea to dev roadmap. FREE.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        idea: { type: 'string', description: 'The idea or feature to add' },
+        priority: { type: 'string', enum: ['low', 'medium', 'high', 'critical'], default: 'medium' },
+        tags: { type: 'array', items: { type: 'string' }, description: 'Tags for categorization' }
+      },
+      required: ['idea']
+    },
+    cost: 0,
+    tier: 'free'
+  },
+  {
+    name: 'roadmap_list',
+    description: 'List roadmap ideas. FREE.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        filter: { type: 'string', description: 'Filter by priority or tag' }
+      }
+    },
+    cost: 0,
+    tier: 'free'
+  },
+  {
+    name: 'roadmap_update',
+    description: 'Update roadmap item status. FREE.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        id: { type: 'string', description: 'Roadmap item ID' },
+        status: { type: 'string', enum: ['idea', 'planned', 'in_progress', 'done', 'archived'] },
+        priority: { type: 'string', enum: ['low', 'medium', 'high', 'critical'] },
+        notes: { type: 'string', description: 'Additional notes' }
+      },
+      required: ['id']
+    },
+    cost: 0,
+    tier: 'free'
+  },
+  {
+    name: 'roadmap_delete',
+    description: 'Delete roadmap item. FREE.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        id: { type: 'string', description: 'Roadmap item ID to delete' }
+      },
+      required: ['id']
+    },
+    cost: 0,
+    tier: 'free'
   }
 ];
 
@@ -200,6 +272,14 @@ async function handleTool(name, args) {
         return await ideConversation(args.session_id, args.message, args.mode);
       case 'learning_stats':
         return await learningStats();
+      case 'roadmap_add':
+        return await roadmapAdd(args.idea, args.priority, args.tags);
+      case 'roadmap_list':
+        return await roadmapList(args.filter);
+      case 'roadmap_update':
+        return await roadmapUpdate(args.id, args);
+      case 'roadmap_delete':
+        return await roadmapDelete(args.id);
       default:
         return { error: `Unknown beacon tool: ${name}` };
     }
@@ -220,5 +300,9 @@ module.exports = {
   priceIt,
   compute,
   ideConversation,
-  learningStats
+  learningStats,
+  roadmapAdd,
+  roadmapList,
+  roadmapUpdate,
+  roadmapDelete
 };

package/lib/packs/librarian.js

@@ -0,0 +1,496 @@
+/**
+ * 50c Librarian Pack - Digital Organization Tools (PRO tier)
+ * Bookmark cleanup, CSV organization, folder structure, file dedup
+ */
+
+const { apiRequest } = require('../config');
+
+// ═══════════════════════════════════════════════════════════════
+//                    BOOKMARK MANAGEMENT
+// ═══════════════════════════════════════════════════════════════
+
+async function bookmarksPrune(bookmarks, options = {}) {
+  return apiRequest('POST', '/tools/librarian/bookmarks_prune', { 
+    bookmarks, 
+    check_dead: options.checkDead !== false,
+    remove_duplicates: options.removeDuplicates !== false
+  });
+}
+
+async function bookmarksOrganize(bookmarks, instruction) {
+  return apiRequest('POST', '/tools/librarian/bookmarks_organize', { 
+    bookmarks, 
+    instruction 
+  });
+}
+
+async function bookmarksParse(filePath) {
+  return apiRequest('POST', '/tools/librarian/bookmarks_parse', { file_path: filePath });
+}
+
+// ═══════════════════════════════════════════════════════════════
+//                      CSV MANAGEMENT
+// ═══════════════════════════════════════════════════════════════
+
+async function csvClean(csvContent, options = {}) {
+  return apiRequest('POST', '/tools/librarian/csv_clean', {
+    csv: csvContent,
+    remove_empty: options.removeEmpty !== false,
+    trim_whitespace: options.trimWhitespace !== false,
+    remove_duplicates: options.removeDuplicates || false,
+    normalize_headers: options.normalizeHeaders || false
+  });
+}
+
+async function csvOrganize(csvContent, instruction) {
+  return apiRequest('POST', '/tools/librarian/csv_organize', {
+    csv: csvContent,
+    instruction
+  });
+}
+
+async function csvMerge(csvFiles, options = {}) {
+  return apiRequest('POST', '/tools/librarian/csv_merge', {
+    files: csvFiles,
+    deduplicate: options.deduplicate || false,
+    key_column: options.keyColumn
+  });
+}
+
+async function csvSplit(csvContent, options) {
+  return apiRequest('POST', '/tools/librarian/csv_split', {
+    csv: csvContent,
+    split_by: options.splitBy,
+    max_rows: options.maxRows
+  });
+}
+
+// ═══════════════════════════════════════════════════════════════
+//                    FOLDER MANAGEMENT
+// ═══════════════════════════════════════════════════════════════
+
+async function folderAnalyze(fileList) {
+  return apiRequest('POST', '/tools/librarian/folder_analyze', { files: fileList });
+}
+
+async function folderOrganize(fileList, instruction) {
+  return apiRequest('POST', '/tools/librarian/folder_organize', {
+    files: fileList,
+    instruction
+  });
+}
+
+async function folderDedup(fileList, options = {}) {
+  return apiRequest('POST', '/tools/librarian/folder_dedup', {
+    files: fileList,
+    by_name: options.byName || false,
+    by_hash: options.byHash || false,
+    by_size: options.bySize || true
+  });
+}
+
+async function folderPlan(fileList, instruction) {
+  return apiRequest('POST', '/tools/librarian/folder_plan', {
+    files: fileList,
+    instruction
+  });
+}
+
+// ═══════════════════════════════════════════════════════════════
+//                    TOOL DEFINITIONS
+// ═══════════════════════════════════════════════════════════════
+
+const LIBRARIAN_TOOLS = [
+  {
+    name: 'bookmarks_prune',
+    description: 'Check bookmarks for dead links (404s) and duplicates. $0.05',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        bookmarks: { type: 'array', items: { type: 'object' }, description: 'Array of {url, title, folder?}' },
+        check_dead: { type: 'boolean', default: true, description: 'Check for 404s' },
+        remove_duplicates: { type: 'boolean', default: true }
+      },
+      required: ['bookmarks']
+    },
+    cost: 0.05,
+    tier: 'pro'
+  },
+  {
+    name: 'bookmarks_organize',
+    description: 'Reorganize bookmarks into folders via LLM instruction. $0.10',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        bookmarks: { type: 'array', items: { type: 'object' }, description: 'Array of bookmarks' },
+        instruction: { type: 'string', description: 'How to organize (e.g., "by topic", "by project")' }
+      },
+      required: ['bookmarks', 'instruction']
+    },
+    cost: 0.10,
+    tier: 'pro'
+  },
+  {
+    name: 'bookmarks_parse',
+    description: 'Parse browser bookmark export file. $0.02',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        file_path: { type: 'string', description: 'Path to bookmarks HTML file' }
+      },
+      required: ['file_path']
+    },
+    cost: 0.02,
+    tier: 'pro'
+  },
+  {
+    name: 'csv_clean',
+    description: 'Clean CSV: remove empty rows, trim whitespace, normalize. $0.03',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        csv: { type: 'string', description: 'CSV content' },
+        remove_empty: { type: 'boolean', default: true },
+        trim_whitespace: { type: 'boolean', default: true },
+        remove_duplicates: { type: 'boolean', default: false },
+        normalize_headers: { type: 'boolean', default: false }
+      },
+      required: ['csv']
+    },
+    cost: 0.03,
+    tier: 'pro'
+  },
+  {
+    name: 'csv_organize',
+    description: 'Reorganize CSV columns/rows via LLM instruction. $0.08',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        csv: { type: 'string', description: 'CSV content' },
+        instruction: { type: 'string', description: 'How to reorganize' }
+      },
+      required: ['csv', 'instruction']
+    },
+    cost: 0.08,
+    tier: 'pro'
+  },
+  {
+    name: 'csv_merge',
+    description: 'Merge multiple CSVs intelligently. $0.05',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        files: { type: 'array', items: { type: 'string' }, description: 'Array of CSV contents' },
+        deduplicate: { type: 'boolean', default: false },
+        key_column: { type: 'string', description: 'Column to use as key for dedup' }
+      },
+      required: ['files']
+    },
+    cost: 0.05,
+    tier: 'pro'
+  },
+  {
+    name: 'csv_split',
+    description: 'Split CSV by column value or row count. $0.03',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        csv: { type: 'string', description: 'CSV content' },
+        split_by: { type: 'string', description: 'Column name to split by' },
+        max_rows: { type: 'number', description: 'Max rows per file' }
+      },
+      required: ['csv']
+    },
+    cost: 0.03,
+    tier: 'pro'
+  },
+  {
+    name: 'folder_analyze',
+    description: 'Analyze folder structure: size, types, duplicates. $0.03',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        files: { type: 'array', items: { type: 'object' }, description: 'Array of {path, size, modified}' }
+      },
+      required: ['files']
+    },
+    cost: 0.03,
+    tier: 'pro'
+  },
+  {
+    name: 'folder_organize',
+    description: 'Generate folder reorganization plan via LLM. $0.10',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        files: { type: 'array', items: { type: 'object' }, description: 'File list' },
+        instruction: { type: 'string', description: 'Organization goal' }
+      },
+      required: ['files', 'instruction']
+    },
+    cost: 0.10,
+    tier: 'pro'
+  },
+  {
+    name: 'folder_dedup',
+    description: 'Find duplicate files by name/hash/size. $0.05',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        files: { type: 'array', items: { type: 'object' }, description: 'Array of {path, size, hash?}' },
+        by_name: { type: 'boolean', default: false },
+        by_hash: { type: 'boolean', default: false },
+        by_size: { type: 'boolean', default: true }
+      },
+      required: ['files']
+    },
+    cost: 0.05,
+    tier: 'pro'
+  },
+  {
+    name: 'folder_plan',
+    description: 'Create actionable file organization plan. $0.08',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        files: { type: 'array', items: { type: 'object' }, description: 'File list' },
+        instruction: { type: 'string', description: 'What to achieve' }
+      },
+      required: ['files', 'instruction']
+    },
+    cost: 0.08,
+    tier: 'pro'
+  },
+
+  // ═══════════════════════════════════════════════════════════════
+  //                    DOMAIN MANAGEMENT
+  // ═══════════════════════════════════════════════════════════════
+  {
+    name: 'domains_add',
+    description: 'Add domain to your portfolio with registrar data. FREE.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        domain: { type: 'string', description: 'Domain name' },
+        registrar: { type: 'string', description: 'Registrar name' },
+        expiry: { type: 'string', description: 'Expiry date (YYYY-MM-DD)' },
+        auto_renew: { type: 'boolean', default: true },
+        purchase_price: { type: 'number' },
+        category: { type: 'string', description: 'Category/project' },
+        notes: { type: 'string' }
+      },
+      required: ['domain']
+    },
+    cost: 0,
+    tier: 'pro'
+  },
+  {
+    name: 'domains_list',
+    description: 'List your domain portfolio. FREE.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        expiring_within: { type: 'number', description: 'Days until expiry filter' },
+        category: { type: 'string' },
+        registrar: { type: 'string' }
+      }
+    },
+    cost: 0,
+    tier: 'pro'
+  },
+  {
+    name: 'domains_expiring',
+    description: 'Get domains expiring soon. FREE.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        days: { type: 'number', default: 30, description: 'Within X days' }
+      }
+    },
+    cost: 0,
+    tier: 'pro'
+  },
+  {
+    name: 'domains_suggest',
+    description: 'Suggest domains matching your portfolio style. $0.05',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        concept: { type: 'string', description: 'What the domain is for' },
+        style: { type: 'string', enum: ['short', 'brandable', 'keyword', 'match_portfolio'], default: 'match_portfolio' }
+      },
+      required: ['concept']
+    },
+    cost: 0.05,
+    tier: 'pro'
+  },
+  {
+    name: 'domains_value',
+    description: 'Estimate domain portfolio value. $0.05',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        domains: { type: 'array', items: { type: 'string' }, description: 'Domains to value (or omit for all)' }
+      }
+    },
+    cost: 0.05,
+    tier: 'pro'
+  },
+
+  // ═══════════════════════════════════════════════════════════════
+  //                    EMAIL/WRITING STYLE
+  // ═══════════════════════════════════════════════════════════════
+  {
+    name: 'writing_sample_add',
+    description: 'Store a writing sample to learn your style. FREE.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        content: { type: 'string', description: 'Your writing sample' },
+        type: { type: 'string', enum: ['email', 'blog', 'social', 'formal', 'casual', 'sales'], default: 'email' },
+        audience: { type: 'string', description: 'Who this was written for' },
+        context: { type: 'string', description: 'What was the situation' }
+      },
+      required: ['content']
+    },
+    cost: 0,
+    tier: 'pro'
+  },
+  {
+    name: 'writing_style_analyze',
+    description: 'Analyze your writing style from samples. $0.08',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        type: { type: 'string', description: 'Filter by type' }
+      }
+    },
+    cost: 0.08,
+    tier: 'pro'
+  },
+  {
+    name: 'writing_draft',
+    description: 'Draft content in YOUR style. $0.10',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        purpose: { type: 'string', description: 'What to write' },
+        audience: { type: 'string', description: 'Who is this for' },
+        type: { type: 'string', enum: ['email', 'blog', 'social', 'formal', 'casual', 'sales'], default: 'email' },
+        tone: { type: 'string', description: 'Override detected tone' }
+      },
+      required: ['purpose']
+    },
+    cost: 0.10,
+    tier: 'pro'
+  },
+  {
+    name: 'writing_improve',
+    description: 'Improve text while keeping your voice. $0.08',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        content: { type: 'string', description: 'Text to improve' },
+        goal: { type: 'string', enum: ['clarity', 'persuasion', 'brevity', 'warmth', 'authority'], default: 'clarity' }
+      },
+      required: ['content']
+    },
+    cost: 0.08,
+    tier: 'pro'
+  },
+  {
+    name: 'writing_roast',
+    description: 'Brutally honest feedback on your writing. $0.05',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        content: { type: 'string', description: 'Text to roast' },
+        context: { type: 'string', description: 'What this is for' }
+      },
+      required: ['content']
+    },
+    cost: 0.05,
+    tier: 'pro'
+  },
+  {
+    name: 'email_templates_list',
+    description: 'List your email templates by situation. FREE.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        situation: { type: 'string', description: 'Filter by situation type' }
+      }
+    },
+    cost: 0,
+    tier: 'pro'
+  },
+  {
+    name: 'email_generate',
+    description: 'Generate email from your templates + style. $0.08',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        to: { type: 'string', description: 'Recipient description' },
+        purpose: { type: 'string', description: 'What the email should accomplish' },
+        context: { type: 'string', description: 'Background info' },
+        tone: { type: 'string', enum: ['professional', 'friendly', 'urgent', 'apologetic', 'persuasive'] }
+      },
+      required: ['purpose']
+    },
+    cost: 0.08,
+    tier: 'pro'
+  }
+];
+
+// ═══════════════════════════════════════════════════════════════
+//                      TOOL HANDLER
+// ═══════════════════════════════════════════════════════════════
+
+async function handleTool(name, args) {
+  try {
+    switch (name) {
+      case 'bookmarks_prune':
+        return await bookmarksPrune(args.bookmarks, args);
+      case 'bookmarks_organize':
+        return await bookmarksOrganize(args.bookmarks, args.instruction);
+      case 'bookmarks_parse':
+        return await bookmarksParse(args.file_path);
+      case 'csv_clean':
+        return await csvClean(args.csv, args);
+      case 'csv_organize':
+        return await csvOrganize(args.csv, args.instruction);
+      case 'csv_merge':
+        return await csvMerge(args.files, args);
+      case 'csv_split':
+        return await csvSplit(args.csv, args);
+      case 'folder_analyze':
+        return await folderAnalyze(args.files);
+      case 'folder_organize':
+        return await folderOrganize(args.files, args.instruction);
+      case 'folder_dedup':
+        return await folderDedup(args.files, args);
+      case 'folder_plan':
+        return await folderPlan(args.files, args.instruction);
+      default:
+        return { error: `Unknown librarian tool: ${name}` };
+    }
+  } catch (e) {
+    return { error: e.message };
+  }
+}
+
+module.exports = {
+  LIBRARIAN_TOOLS,
+  handleTool,
+  bookmarksPrune,
+  bookmarksOrganize,
+  bookmarksParse,
+  csvClean,
+  csvOrganize,
+  csvMerge,
+  csvSplit,
+  folderAnalyze,
+  folderOrganize,
+  folderDedup,
+  folderPlan
+};

package/lib/packs/whm.js

@@ -15,9 +15,10 @@ async function getWHMCreds() {
   try {
     if (await vault.isUnlocked()) {
       const creds = await vault.get('whm/default');
+      const host = await vault.get('whm/host');
       if (creds) {
         const [user, token] = creds.split(':');
-        return { host: process.env.WHM_HOST, user, token };
+        return { host: host || process.env.WHM_HOST, user, token };
       }
     }
   } catch {}

package/lib/packs.js

@@ -26,11 +26,11 @@ const PACKS = {
   },
   vault: {
     name: 'vault',
-    description: 'Secure credential storage',
-    tools: 9,
+    description: 'Secure storage + Dewey index card catalog',
+    tools: 19,
     tier: 'free',
     always_on: true,
-    highlights: ['vault_add', 'vault_get', 'vault_yolo']
+    highlights: ['vault_yolo', 'dewey_add', 'dewey_search', 'dewey_stats']
   },
 
   // === STARTER TIER ($29/mo) ===
@@ -73,6 +73,13 @@ const PACKS = {
     tier: 'pro',
     highlights: ['ux_list_blocks', 'ux_ab_compare', 'ux_a11y_check']
   },
+  librarian: {
+    name: 'librarian',
+    description: 'Digital asset manager - domains, bookmarks, CSV, folders, writing style',
+    tools: 24,
+    tier: 'pro',
+    highlights: ['domains_expiring', 'writing_draft', 'bookmarks_prune', 'csv_clean']
+  },
 
   // === ENTERPRISE TIER ($499/mo) ===
   labs_plus: {
@@ -110,6 +117,17 @@ const TOOL_TIERS = {
   vault_get: 'free',
   vault_list: 'free',
   vault_delete: 'free',
+  vault_add_proxies: 'free',
+  vault_get_proxy: 'free',
+  vault_list_proxies: 'free',
+  // Dewey Index (free - local vault)
+  dewey_add: 'free',
+  dewey_get: 'free',
+  dewey_search: 'free',
+  dewey_list: 'free',
+  dewey_update: 'free',
+  dewey_delete: 'free',
+  dewey_stats: 'free',
 
   // STARTER ($29/mo)
   hints: 'starter',
@@ -166,6 +184,37 @@ const TOOL_TIERS = {
   ux_a11y_check: 'pro',
   ux_color_palette: 'pro',
   ux_contrast_check: 'pro',
+  // Librarian tools
+  bookmarks_prune: 'pro',
+  bookmarks_organize: 'pro',
+  bookmarks_parse: 'pro',
+  csv_clean: 'pro',
+  csv_organize: 'pro',
+  csv_merge: 'pro',
+  csv_split: 'pro',
+  folder_analyze: 'pro',
+  folder_organize: 'pro',
+  folder_dedup: 'pro',
+  folder_plan: 'pro',
+  // Domain portfolio
+  domains_add: 'pro',
+  domains_list: 'pro',
+  domains_expiring: 'pro',
+  domains_suggest: 'pro',
+  domains_value: 'pro',
+  // Writing style
+  writing_sample_add: 'pro',
+  writing_style_analyze: 'pro',
+  writing_draft: 'pro',
+  writing_improve: 'pro',
+  writing_roast: 'pro',
+  email_templates_list: 'pro',
+  email_generate: 'pro',
+  // Roadmap (free - per user)
+  roadmap_add: 'free',
+  roadmap_list: 'free',
+  roadmap_update: 'free',
+  roadmap_delete: 'free',
 
   // ENTERPRISE ($499/mo)
   genius_plus: 'enterprise',
@@ -346,7 +395,7 @@ const PACK_TOOLS = [
     inputSchema: {
       type: 'object',
       properties: {
-        pack: { type: 'string', description: 'Pack name', enum: ['beacon', 'labs', 'labs_plus', 'whm', 'cf', 'wp', 'ux'] }
+        pack: { type: 'string', description: 'Pack name', enum: ['beacon', 'labs', 'labs_plus', 'whm', 'cf', 'wp', 'ux', 'librarian'] }
       },
       required: ['pack']
     }

package/lib/vault.js

@@ -304,6 +304,298 @@ async function yolo(passphrase) {
   return unlock(passphrase, 365 * 24 * 3600);
 }
 
+// Proxy list management
+async function addProxies(name, proxyList) {
+  const masterKey = await getMasterKey();
+  if (!masterKey) throw new Error('Vault locked. Unlock first.');
+  
+  const proxies = typeof proxyList === 'string' 
+    ? proxyList.split('\n').map(p => p.trim()).filter(p => p && p.includes(':'))
+    : proxyList;
+  
+  const data = JSON.stringify({ proxies, added_at: Date.now(), count: proxies.length });
+  const encrypted = encrypt(data, masterKey);
+  
+  if (MODE === 'local') {
+    const db = loadLocalDB();
+    db.credentials[`proxies/${name}`] = { encrypted, updated_at: Date.now() };
+    saveLocalDB(db);
+  } else {
+    await apiRequest('POST', '/vault/credentials', { name: `proxies/${name}`, encrypted });
+  }
+  
+  return { success: true, name, count: proxies.length };
+}
+
+async function getProxies(name, random = false) {
+  const masterKey = await getMasterKey();
+  if (!masterKey) throw new Error('Vault locked. Unlock first.');
+  
+  let encrypted;
+  const fullName = `proxies/${name}`;
+  
+  if (MODE === 'local') {
+    const db = loadLocalDB();
+    if (!db.credentials[fullName]) throw new Error(`Proxy list not found: ${name}`);
+    encrypted = db.credentials[fullName].encrypted;
+  } else {
+    const response = await apiRequest('GET', `/vault/credentials/${encodeURIComponent(fullName)}`);
+    if (!response?.encrypted) throw new Error(`Proxy list not found: ${name}`);
+    encrypted = response.encrypted;
+  }
+  
+  const data = JSON.parse(decrypt(encrypted, masterKey));
+  
+  if (random) {
+    const idx = Math.floor(Math.random() * data.proxies.length);
+    return { proxy: data.proxies[idx], total: data.count };
+  }
+  
+  return data;
+}
+
+async function listProxies() {
+  const all = await list('proxies');
+  return all.map(n => n.replace('proxies/', ''));
+}
+
+// ═══════════════════════════════════════════════════════════════
+//              DEWEY INDEX - Digital Card Catalog
+//        Index cards for files, articles, books, anything
+// ═══════════════════════════════════════════════════════════════
+
+async function deweyAdd(card) {
+  const masterKey = await getMasterKey();
+  if (!masterKey) throw new Error('Vault locked. Unlock first.');
+  
+  const id = card.id || `dew_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
+  const now = Date.now();
+  
+  const indexCard = {
+    id,
+    type: card.type || 'file',           // file, article, book, idea, snippet, email, url
+    title: card.title || 'Untitled',
+    location: card.location || null,      // file path, URL, or null
+    category: card.category || 'uncategorized',
+    tags: card.tags || [],
+    summary: card.summary || null,        // LLM-generated or manual
+    content_preview: card.content_preview || null,  // first 500 chars
+    metadata: {
+      author: card.author || null,
+      date_created: card.date_created || null,
+      date_read: card.date_read || null,
+      rating: card.rating || null,        // 1-5
+      notes: card.notes || null,          // personal notes
+      source: card.source || null,        // goodreads, audible, local, web
+      ...card.metadata
+    },
+    indexed_at: now,
+    updated_at: now
+  };
+  
+  const encrypted = encrypt(JSON.stringify(indexCard), masterKey);
+  
+  if (MODE === 'local') {
+    const db = loadLocalDB();
+    db.credentials[`dewey/${id}`] = { encrypted, updated_at: now };
+    saveLocalDB(db);
+  } else {
+    await apiRequest('POST', '/vault/credentials', { name: `dewey/${id}`, encrypted });
+  }
+  
+  return { id, title: indexCard.title, type: indexCard.type, indexed: true };
+}
+
+async function deweyGet(id) {
+  const masterKey = await getMasterKey();
+  if (!masterKey) throw new Error('Vault locked. Unlock first.');
+  
+  let encrypted;
+  const fullName = `dewey/${id}`;
+  
+  if (MODE === 'local') {
+    const db = loadLocalDB();
+    if (!db.credentials[fullName]) throw new Error(`Card not found: ${id}`);
+    encrypted = db.credentials[fullName].encrypted;
+  } else {
+    const response = await apiRequest('GET', `/vault/credentials/${encodeURIComponent(fullName)}`);
+    if (!response?.encrypted) throw new Error(`Card not found: ${id}`);
+    encrypted = response.encrypted;
+  }
+  
+  return JSON.parse(decrypt(encrypted, masterKey));
+}
+
+async function deweySearch(query) {
+  const masterKey = await getMasterKey();
+  if (!masterKey) throw new Error('Vault locked. Unlock first.');
+  
+  const allCards = await list('dewey');
+  const results = [];
+  const q = query.toLowerCase();
+  
+  for (const name of allCards) {
+    try {
+      let encrypted;
+      if (MODE === 'local') {
+        const db = loadLocalDB();
+        encrypted = db.credentials[name]?.encrypted;
+      } else {
+        const response = await apiRequest('GET', `/vault/credentials/${encodeURIComponent(name)}`);
+        encrypted = response?.encrypted;
+      }
+      
+      if (encrypted) {
+        const card = JSON.parse(decrypt(encrypted, masterKey));
+        // Search in title, tags, category, summary, notes
+        const searchable = [
+          card.title,
+          card.category,
+          card.summary,
+          card.metadata?.notes,
+          card.metadata?.author,
+          ...(card.tags || [])
+        ].filter(Boolean).join(' ').toLowerCase();
+        
+        if (searchable.includes(q)) {
+          results.push({
+            id: card.id,
+            type: card.type,
+            title: card.title,
+            category: card.category,
+            tags: card.tags,
+            rating: card.metadata?.rating,
+            date_read: card.metadata?.date_read
+          });
+        }
+      }
+    } catch {}
+  }
+  
+  return { query, results, count: results.length };
+}
+
+async function deweyList(options = {}) {
+  const masterKey = await getMasterKey();
+  if (!masterKey) throw new Error('Vault locked. Unlock first.');
+  
+  const allCards = await list('dewey');
+  const results = [];
+  
+  for (const name of allCards) {
+    try {
+      let encrypted;
+      if (MODE === 'local') {
+        const db = loadLocalDB();
+        encrypted = db.credentials[name]?.encrypted;
+      } else {
+        const response = await apiRequest('GET', `/vault/credentials/${encodeURIComponent(name)}`);
+        encrypted = response?.encrypted;
+      }
+      
+      if (encrypted) {
+        const card = JSON.parse(decrypt(encrypted, masterKey));
+        
+        // Filter by type
+        if (options.type && card.type !== options.type) continue;
+        // Filter by category
+        if (options.category && card.category !== options.category) continue;
+        // Filter by tag
+        if (options.tag && !card.tags?.includes(options.tag)) continue;
+        // Filter by rating
+        if (options.min_rating && (card.metadata?.rating || 0) < options.min_rating) continue;
+        
+        results.push({
+          id: card.id,
+          type: card.type,
+          title: card.title,
+          category: card.category,
+          tags: card.tags,
+          rating: card.metadata?.rating,
+          location: card.location,
+          indexed_at: card.indexed_at
+        });
+      }
+    } catch {}
+  }
+  
+  // Sort by indexed_at desc
+  results.sort((a, b) => (b.indexed_at || 0) - (a.indexed_at || 0));
+  
+  return { 
+    cards: results.slice(0, options.limit || 50), 
+    total: results.length,
+    filters: { type: options.type, category: options.category, tag: options.tag }
+  };
+}
+
+async function deweyUpdate(id, updates) {
+  const masterKey = await getMasterKey();
+  if (!masterKey) throw new Error('Vault locked. Unlock first.');
+  
+  const card = await deweyGet(id);
+  
+  // Merge updates
+  if (updates.title) card.title = updates.title;
+  if (updates.category) card.category = updates.category;
+  if (updates.tags) card.tags = updates.tags;
+  if (updates.summary) card.summary = updates.summary;
+  if (updates.rating !== undefined) card.metadata.rating = updates.rating;
+  if (updates.notes) card.metadata.notes = updates.notes;
+  if (updates.date_read) card.metadata.date_read = updates.date_read;
+  card.updated_at = Date.now();
+  
+  const encrypted = encrypt(JSON.stringify(card), masterKey);
+  
+  if (MODE === 'local') {
+    const db = loadLocalDB();
+    db.credentials[`dewey/${id}`] = { encrypted, updated_at: card.updated_at };
+    saveLocalDB(db);
+  } else {
+    await apiRequest('POST', '/vault/credentials', { name: `dewey/${id}`, encrypted });
+  }
+  
+  return { id, updated: true };
+}
+
+async function deweyDelete(id) {
+  return remove(`dewey/${id}`);
+}
+
+async function deweyStats() {
+  const masterKey = await getMasterKey();
+  if (!masterKey) throw new Error('Vault locked. Unlock first.');
+  
+  const allCards = await list('dewey');
+  const stats = {
+    total: allCards.length,
+    by_type: {},
+    by_category: {},
+    rated: 0,
+    unread: 0
+  };
+  
+  for (const name of allCards) {
+    try {
+      let encrypted;
+      if (MODE === 'local') {
+        const db = loadLocalDB();
+        encrypted = db.credentials[name]?.encrypted;
+      }
+      
+      if (encrypted) {
+        const card = JSON.parse(decrypt(encrypted, masterKey));
+        stats.by_type[card.type] = (stats.by_type[card.type] || 0) + 1;
+        stats.by_category[card.category] = (stats.by_category[card.category] || 0) + 1;
+        if (card.metadata?.rating) stats.rated++;
+        if (card.type === 'book' && !card.metadata?.date_read) stats.unread++;
+      }
+    } catch {}
+  }
+  
+  return stats;
+}
+
 // Tool definitions for MCP
 const VAULT_TOOLS = [
   { name: 'vault_status', description: 'Check vault status. FREE.', inputSchema: { type: 'object', properties: {} } },
@@ -314,7 +606,44 @@ const VAULT_TOOLS = [
   { name: 'vault_add', description: 'Add credential to vault. FREE.', inputSchema: { type: 'object', properties: { name: { type: 'string' }, value: { type: 'string' } }, required: ['name', 'value'] } },
   { name: 'vault_get', description: 'Get credential from vault. FREE.', inputSchema: { type: 'object', properties: { name: { type: 'string' } }, required: ['name'] } },
   { name: 'vault_list', description: 'List credentials in vault. FREE.', inputSchema: { type: 'object', properties: { namespace: { type: 'string' } } } },
-  { name: 'vault_delete', description: 'Delete credential from vault. FREE.', inputSchema: { type: 'object', properties: { name: { type: 'string' } }, required: ['name'] } }
+  { name: 'vault_delete', description: 'Delete credential from vault. FREE.', inputSchema: { type: 'object', properties: { name: { type: 'string' } }, required: ['name'] } },
+  { name: 'vault_add_proxies', description: 'Store proxy list in vault. FREE.', inputSchema: { type: 'object', properties: { name: { type: 'string', description: 'List name (e.g., residential, datacenter)' }, proxy_list: { type: 'string', description: 'Newline-separated IP:PORT:USER:PASS' } }, required: ['name', 'proxy_list'] } },
+  { name: 'vault_get_proxy', description: 'Get proxy from stored list. FREE.', inputSchema: { type: 'object', properties: { name: { type: 'string', description: 'List name' }, random: { type: 'boolean', default: true, description: 'Return random proxy' } }, required: ['name'] } },
+  { name: 'vault_list_proxies', description: 'List stored proxy lists. FREE.', inputSchema: { type: 'object', properties: {} } },
+  // Dewey Index - Digital Card Catalog
+  { name: 'dewey_add', description: 'Add item to Dewey index (file, article, book, idea). FREE.', inputSchema: { type: 'object', properties: { 
+    type: { type: 'string', enum: ['file', 'article', 'book', 'idea', 'snippet', 'email', 'url'], default: 'file' },
+    title: { type: 'string', description: 'Title of the item' },
+    location: { type: 'string', description: 'File path or URL' },
+    category: { type: 'string', description: 'Category/topic' },
+    tags: { type: 'array', items: { type: 'string' } },
+    summary: { type: 'string', description: 'Brief summary' },
+    author: { type: 'string' },
+    rating: { type: 'number', minimum: 1, maximum: 5 },
+    notes: { type: 'string', description: 'Personal notes' },
+    source: { type: 'string', description: 'Where from (goodreads, audible, local, web)' }
+  }, required: ['title'] } },
+  { name: 'dewey_get', description: 'Get full details of indexed item. FREE.', inputSchema: { type: 'object', properties: { id: { type: 'string' } }, required: ['id'] } },
+  { name: 'dewey_search', description: 'Search your Dewey index. FREE.', inputSchema: { type: 'object', properties: { query: { type: 'string', description: 'Search in titles, tags, notes, authors' } }, required: ['query'] } },
+  { name: 'dewey_list', description: 'List items in Dewey index with filters. FREE.', inputSchema: { type: 'object', properties: { 
+    type: { type: 'string', description: 'Filter by type' },
+    category: { type: 'string', description: 'Filter by category' },
+    tag: { type: 'string', description: 'Filter by tag' },
+    min_rating: { type: 'number', description: 'Minimum rating filter' },
+    limit: { type: 'number', default: 50 }
+  } } },
+  { name: 'dewey_update', description: 'Update indexed item. FREE.', inputSchema: { type: 'object', properties: {
+    id: { type: 'string' },
+    title: { type: 'string' },
+    category: { type: 'string' },
+    tags: { type: 'array', items: { type: 'string' } },
+    summary: { type: 'string' },
+    rating: { type: 'number' },
+    notes: { type: 'string' },
+    date_read: { type: 'string', description: 'When you read/consumed it' }
+  }, required: ['id'] } },
+  { name: 'dewey_delete', description: 'Remove item from Dewey index. FREE.', inputSchema: { type: 'object', properties: { id: { type: 'string' } }, required: ['id'] } },
+  { name: 'dewey_stats', description: 'Get stats on your Dewey index. FREE.', inputSchema: { type: 'object', properties: {} } }
 ];
 
 // Handle vault tool calls
@@ -330,6 +659,17 @@ async function handleTool(name, args) {
       case 'vault_get': return { value: await get(args.name) };
       case 'vault_list': return { credentials: await list(args.namespace) };
       case 'vault_delete': return await remove(args.name);
+      case 'vault_add_proxies': return await addProxies(args.name, args.proxy_list);
+      case 'vault_get_proxy': return await getProxies(args.name, args.random !== false);
+      case 'vault_list_proxies': return { lists: await listProxies() };
+      // Dewey Index
+      case 'dewey_add': return await deweyAdd(args);
+      case 'dewey_get': return await deweyGet(args.id);
+      case 'dewey_search': return await deweySearch(args.query);
+      case 'dewey_list': return await deweyList(args);
+      case 'dewey_update': return await deweyUpdate(args.id, args);
+      case 'dewey_delete': return await deweyDelete(args.id);
+      case 'dewey_stats': return await deweyStats();
       default: return { error: `Unknown vault tool: ${name}` };
     }
   } catch (e) {
@@ -350,5 +690,15 @@ module.exports = {
   list,
   remove,
   isUnlocked,
-  getMasterKey
+  getMasterKey,
+  addProxies,
+  getProxies,
+  listProxies,
+  deweyAdd,
+  deweyGet,
+  deweySearch,
+  deweyList,
+  deweyUpdate,
+  deweyDelete,
+  deweyStats
 };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "50c",
-  "version": "2.2.0",
-  "description": "AI toolkit. One install, 100+ tools. Works everywhere.",
+  "version": "2.5.0",
+  "description": "AI toolkit with Dewey index. One install, 100+ tools.",
   "main": "lib/index.js",
   "bin": {
     "50c": "./bin/50c.js"
@@ -19,7 +19,10 @@
     "cloudflare",
     "whm",
     "cpanel",
-    "wordpress"
+    "wordpress",
+    "librarian",
+    "bookmarks",
+    "csv"
   ],
   "author": "genxis.com",
   "license": "MIT",