vacumify-mcp 1.1.0 → 1.2.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
package/lib/scanner.js ADDED
@@ -0,0 +1,604 @@
1
+ const fs = require('fs');
2
+ const fsp = fs.promises;
3
+ const path = require('path');
4
+ const crypto = require('crypto');
5
+ const os = require('os');
6
+ const { spawnSync } = require('child_process');
7
+
8
+ const LARGE_FILE_THRESHOLD = 16 * 1024 * 1024; // 16 MB
9
+ const PREFIX_BYTES = 1024;
10
+ const SAMPLE_BLOCK_BYTES = 64 * 1024;
11
+ const HASH_CONCURRENCY = 16;
12
+
13
+ const ALWAYS_EXCLUDED_FOLDERS = new Set([
14
+ '.git',
15
+ 'system volume information',
16
+ '$recycle.bin',
17
+ 'windows',
18
+ 'program files',
19
+ 'program files (x86)',
20
+ 'programdata'
21
+ ]);
22
+
23
+ const HIDDEN_DEV_FOLDERS = new Set([
24
+ '.cache',
25
+ '.npm',
26
+ '.yarn',
27
+ '.pnpm-store',
28
+ '.gradle',
29
+ '.m2',
30
+ '.nuget',
31
+ '.cargo',
32
+ '.rustup',
33
+ '.docker',
34
+ '.android',
35
+ '.vscode',
36
+ '.vs'
37
+ ]);
38
+
39
+ function formatBytes(bytes) {
40
+ if (!bytes || bytes <= 0) return '0 B';
41
+ const units = ['B', 'KB', 'MB', 'GB', 'TB'];
42
+ let idx = 0;
43
+ let val = bytes;
44
+ while (val >= 1024 && idx < units.length - 1) {
45
+ val /= 1024;
46
+ idx++;
47
+ }
48
+ return idx === 0 ? `${Math.round(val)} B` : `${val.toFixed(2).replace(/\.?0+$/, '')} ${units[idx]}`;
49
+ }
50
+
51
+ function formatDate(ms) {
52
+ const d = new Date(ms);
53
+ const pad = (n) => String(n).padStart(2, '0');
54
+ return `${d.getFullYear()}-${pad(d.getMonth() + 1)}-${pad(d.getDate())} ${pad(d.getHours())}:${pad(d.getMinutes())}`;
55
+ }
56
+
57
+ function getProtectedRoots() {
58
+ if (process.platform === 'win32') {
59
+ const winDir = process.env.WINDIR || 'C:\\Windows';
60
+ const progFiles = process.env.ProgramFiles || 'C:\\Program Files';
61
+ const progFilesX86 = process.env['ProgramFiles(x86)'] || 'C:\\Program Files (x86)';
62
+ const progData = process.env.ProgramData || 'C:\\ProgramData';
63
+ const appData = process.env.APPDATA || '';
64
+ const localAppData = process.env.LOCALAPPDATA || '';
65
+ return [winDir, progFiles, progFilesX86, progData, appData, localAppData]
66
+ .filter(Boolean)
67
+ .map((p) => path.resolve(p).toLowerCase());
68
+ }
69
+ return ['/system', '/library', '/bin', '/sbin', '/usr', '/etc', '/var', '/dev', '/proc', '/sys']
70
+ .map((p) => path.resolve(p).toLowerCase());
71
+ }
72
+
73
+ const PROTECTED_ROOTS = getProtectedRoots();
74
+
75
+ function isProtectedRoot(targetPath) {
76
+ try {
77
+ const norm = path.resolve(targetPath).toLowerCase();
78
+ return PROTECTED_ROOTS.includes(norm);
79
+ } catch {
80
+ return true;
81
+ }
82
+ }
83
+
84
+ function isProtectedPath(targetPath) {
85
+ try {
86
+ const norm = path.resolve(targetPath).toLowerCase();
87
+ return PROTECTED_ROOTS.some((root) => norm === root || norm.startsWith(root + path.sep));
88
+ } catch {
89
+ return true;
90
+ }
91
+ }
92
+
93
+ async function parentHasAnyFile(parentDir, patterns) {
94
+ if (!parentDir) return false;
95
+ try {
96
+ const entries = await fsp.readdir(parentDir);
97
+ for (const name of entries) {
98
+ const lower = name.toLowerCase();
99
+ for (const pat of patterns) {
100
+ if (pat.startsWith('*.')) {
101
+ if (lower.endsWith(pat.slice(1))) return true;
102
+ } else if (lower === pat.toLowerCase()) {
103
+ return true;
104
+ }
105
+ }
106
+ }
107
+ } catch {}
108
+ return false;
109
+ }
110
+
111
+ async function isDevCacheFolder(folderName, parentDir) {
112
+ const lower = folderName.toLowerCase();
113
+ if (lower === 'node_modules') return 'node_modules';
114
+ if (lower === 'venv' || lower === '.venv' || lower === '__pycache__') return 'Python venv';
115
+ if (lower === '.gradle') return 'Gradle';
116
+
117
+ if (lower === 'target' && (await parentHasAnyFile(parentDir, ['Cargo.toml', 'pom.xml']))) {
118
+ return 'Rust target';
119
+ }
120
+ if ((lower === 'bin' || lower === 'obj') && (await parentHasAnyFile(parentDir, ['*.csproj', '*.fsproj', '*.vbproj', '*.sln']))) {
121
+ return '.NET bin/obj';
122
+ }
123
+ return null;
124
+ }
125
+
126
+ async function fastGetDirectorySize(dirPath) {
127
+ let total = 0;
128
+ const queue = [dirPath];
129
+ while (queue.length > 0) {
130
+ const current = queue.pop();
131
+ let entries;
132
+ try {
133
+ entries = await fsp.readdir(current, { withFileTypes: true });
134
+ } catch {
135
+ continue;
136
+ }
137
+ for (const entry of entries) {
138
+ if (entry.isSymbolicLink()) continue;
139
+ const full = path.join(current, entry.name);
140
+ if (entry.isDirectory()) {
141
+ queue.push(full);
142
+ } else if (entry.isFile()) {
143
+ try {
144
+ const st = await fsp.stat(full);
145
+ total += st.size;
146
+ } catch {}
147
+ }
148
+ }
149
+ }
150
+ return total;
151
+ }
152
+
153
+ function getExtension(fileName) {
154
+ const ext = path.extname(fileName);
155
+ return ext ? ext.slice(1).toUpperCase() : '';
156
+ }
157
+
158
+ async function computePrefixHash(filePath, size) {
159
+ const len = Math.min(PREFIX_BYTES, size);
160
+ const fh = await fsp.open(filePath, 'r');
161
+ try {
162
+ const buf = Buffer.allocUnsafe(len);
163
+ const { bytesRead } = await fh.read(buf, 0, len, 0);
164
+ return crypto.createHash('sha256').update(buf.subarray(0, bytesRead)).digest('hex');
165
+ } finally {
166
+ await fh.close();
167
+ }
168
+ }
169
+
170
+ async function computeContentHash(filePath, size, fastLargeSampling = true) {
171
+ if (!fastLargeSampling || size <= LARGE_FILE_THRESHOLD) {
172
+ return new Promise((resolve, reject) => {
173
+ const hash = crypto.createHash('sha256');
174
+ const stream = fs.createReadStream(filePath, { highWaterMark: 128 * 1024 });
175
+ stream.on('data', (chunk) => hash.update(chunk));
176
+ stream.on('end', () => resolve(hash.digest('hex')));
177
+ stream.on('error', reject);
178
+ });
179
+ }
180
+
181
+ // 8-point distributed sampling for files > 16 MB
182
+ const fh = await fsp.open(filePath, 'r');
183
+ try {
184
+ const hash = crypto.createHash('sha256');
185
+ const sizeBuf = Buffer.allocUnsafe(8);
186
+ sizeBuf.writeBigInt64LE(BigInt(size));
187
+ hash.update(sizeBuf);
188
+
189
+ const blocks = 8;
190
+ const buf = Buffer.allocUnsafe(SAMPLE_BLOCK_BYTES);
191
+ for (let i = 0; i < blocks; i++) {
192
+ const offset = i === blocks - 1
193
+ ? Math.max(0, size - SAMPLE_BLOCK_BYTES)
194
+ : Math.floor((i * (size - SAMPLE_BLOCK_BYTES)) / (blocks - 1));
195
+ const { bytesRead } = await fh.read(buf, 0, SAMPLE_BLOCK_BYTES, offset);
196
+ if (bytesRead > 0) {
197
+ hash.update(buf.subarray(0, bytesRead));
198
+ }
199
+ }
200
+ return `SAMPLE:${hash.digest('hex')}`;
201
+ } finally {
202
+ await fh.close();
203
+ }
204
+ }
205
+
206
+ async function mapConcurrent(items, limit, fn) {
207
+ const results = new Array(items.length);
208
+ let idx = 0;
209
+ async function worker() {
210
+ while (idx < items.length) {
211
+ const i = idx++;
212
+ results[i] = await fn(items[i], i);
213
+ }
214
+ }
215
+ const workers = Array.from({ length: Math.min(limit, items.length) }, () => worker());
216
+ await Promise.all(workers);
217
+ return results;
218
+ }
219
+
220
+ async function scanDirectory(rootPath, options = {}) {
221
+ const {
222
+ includeHidden = false,
223
+ minDuplicateBytes = 100 * 1024,
224
+ fastLargeSampling = true
225
+ } = options;
226
+
227
+ const resolvedRoot = path.resolve(rootPath);
228
+ if (!fs.existsSync(resolvedRoot)) {
229
+ throw new Error(`Directory does not exist: ${rootPath}`);
230
+ }
231
+
232
+ const files = [];
233
+ const devCaches = [];
234
+ const errors = [];
235
+ let bytesScanned = 0;
236
+
237
+ const queue = [resolvedRoot];
238
+ const seen = new Set([resolvedRoot.toLowerCase()]);
239
+
240
+ while (queue.length > 0) {
241
+ // Process batch concurrently
242
+ const batch = queue.splice(0, 16);
243
+ await Promise.all(batch.map(async (dir) => {
244
+ let entries;
245
+ try {
246
+ entries = await fsp.readdir(dir, { withFileTypes: true });
247
+ } catch (err) {
248
+ errors.push(`${dir}: ${err.message}`);
249
+ return;
250
+ }
251
+
252
+ for (const entry of entries) {
253
+ if (entry.isSymbolicLink()) continue;
254
+ const fullPath = path.join(dir, entry.name);
255
+
256
+ if (entry.isDirectory()) {
257
+ if (isProtectedRoot(fullPath)) continue;
258
+
259
+ const cacheType = await isDevCacheFolder(entry.name, dir);
260
+ if (cacheType) {
261
+ try {
262
+ const st = await fsp.stat(fullPath);
263
+ const cacheSize = await fastGetDirectorySize(fullPath);
264
+ const projName = path.basename(dir) || entry.name;
265
+ devCaches.push({
266
+ path: fullPath,
267
+ projectName: projName,
268
+ cacheType,
269
+ size: cacheSize,
270
+ lastModifiedMs: st.mtimeMs
271
+ });
272
+ } catch {}
273
+ continue;
274
+ }
275
+
276
+ const lowerName = entry.name.toLowerCase();
277
+ if (ALWAYS_EXCLUDED_FOLDERS.has(lowerName)) continue;
278
+ if (!includeHidden && (entry.name.startsWith('.') || HIDDEN_DEV_FOLDERS.has(lowerName))) continue;
279
+
280
+ const key = fullPath.toLowerCase();
281
+ if (!seen.has(key)) {
282
+ seen.add(key);
283
+ queue.push(fullPath);
284
+ }
285
+ } else if (entry.isFile()) {
286
+ try {
287
+ const st = await fsp.stat(fullPath);
288
+ bytesScanned += st.size;
289
+ files.push({
290
+ path: fullPath,
291
+ name: entry.name,
292
+ extension: getExtension(entry.name),
293
+ size: st.size,
294
+ lastAccessMs: st.atimeMs || st.mtimeMs,
295
+ lastWriteMs: st.mtimeMs,
296
+ duplicateGroupId: 0,
297
+ duplicateGroupCount: 0
298
+ });
299
+ } catch (err) {
300
+ errors.push(`${fullPath}: ${err.message}`);
301
+ }
302
+ }
303
+ }
304
+ }));
305
+ }
306
+
307
+ // Duplicate detection (3-stage pipeline)
308
+ const reclaimableDuplicateBytes = await assignDuplicateGroups(files, minDuplicateBytes, fastLargeSampling);
309
+ devCaches.sort((a, b) => b.size - a.size);
310
+
311
+ return {
312
+ files,
313
+ devCaches,
314
+ errors,
315
+ bytesScanned,
316
+ reclaimableDuplicateBytes
317
+ };
318
+ }
319
+
320
+ async function assignDuplicateGroups(files, minDuplicateBytes, fastLargeSampling) {
321
+ const bySize = new Map();
322
+ for (const f of files) {
323
+ if (f.size < minDuplicateBytes) continue;
324
+ let list = bySize.get(f.size);
325
+ if (!list) {
326
+ list = [];
327
+ bySize.set(f.size, list);
328
+ }
329
+ list.push(f);
330
+ }
331
+
332
+ const sizeCandidates = [];
333
+ for (const grp of bySize.values()) {
334
+ if (grp.length > 1) sizeCandidates.push(...grp);
335
+ }
336
+ if (sizeCandidates.length === 0) return 0;
337
+
338
+ // Stage 2: 1 KB prefix hash
339
+ const byPrefix = new Map();
340
+ await mapConcurrent(sizeCandidates, HASH_CONCURRENCY, async (f) => {
341
+ try {
342
+ const pHash = await computePrefixHash(f.path, f.size);
343
+ const key = `${f.size}:${pHash}`;
344
+ let list = byPrefix.get(key);
345
+ if (!list) {
346
+ list = [];
347
+ byPrefix.set(key, list);
348
+ }
349
+ list.push(f);
350
+ } catch {}
351
+ });
352
+
353
+ const prefixCandidates = [];
354
+ for (const grp of byPrefix.values()) {
355
+ if (grp.length > 1) prefixCandidates.push(...grp);
356
+ }
357
+ if (prefixCandidates.length === 0) return 0;
358
+
359
+ // Stage 3: Full / 8-point distributed SHA-256
360
+ const byContent = new Map();
361
+ await mapConcurrent(prefixCandidates, HASH_CONCURRENCY, async (f) => {
362
+ try {
363
+ const cHash = await computeContentHash(f.path, f.size, fastLargeSampling);
364
+ const key = `${f.size}:${cHash}`;
365
+ let list = byContent.get(key);
366
+ if (!list) {
367
+ list = [];
368
+ byContent.set(key, list);
369
+ }
370
+ list.push(f);
371
+ } catch {}
372
+ });
373
+
374
+ let groupId = 1;
375
+ let reclaimable = 0;
376
+ for (const grp of byContent.values()) {
377
+ if (grp.length < 2) continue;
378
+ const count = grp.length;
379
+ reclaimable += (count - 1) * grp[0].size;
380
+ for (const copy of grp) {
381
+ copy.duplicateGroupId = groupId;
382
+ copy.duplicateGroupCount = count;
383
+ }
384
+ groupId++;
385
+ }
386
+
387
+ return reclaimable;
388
+ }
389
+
390
+ function identifySafeJunk(files) {
391
+ const safeList = [];
392
+
393
+ // 1. Redundant duplicate copies (keep newest intact)
394
+ const dupGroups = new Map();
395
+ for (const f of files) {
396
+ if (f.duplicateGroupCount > 1) {
397
+ let arr = dupGroups.get(f.duplicateGroupId);
398
+ if (!arr) {
399
+ arr = [];
400
+ dupGroups.set(f.duplicateGroupId, arr);
401
+ }
402
+ arr.push(f);
403
+ }
404
+ }
405
+ for (const copies of dupGroups.values()) {
406
+ copies.sort((a, b) => b.lastWriteMs - a.lastWriteMs);
407
+ for (let i = 1; i < copies.length; i++) {
408
+ safeList.push(copies[i]);
409
+ }
410
+ }
411
+
412
+ // 2. Obsolete installers & crash dumps (> 30 days untouched)
413
+ const cutoffMs = Date.now() - 30 * 24 * 60 * 60 * 1000;
414
+ for (const f of files) {
415
+ if (f.duplicateGroupCount > 1) continue;
416
+ const ext = f.extension;
417
+ const lowerName = f.name.toLowerCase();
418
+ const isInstaller = ext === 'MSI' ||
419
+ (ext === 'EXE' && (lowerName.includes('setup') || lowerName.includes('installer') || lowerName.includes('install')));
420
+ const isCrashDump = ext === 'DMP' || (ext === 'LOG' && f.size > 20 * 1024 * 1024);
421
+
422
+ if ((isInstaller || isCrashDump) && f.lastAccessMs <= cutoffMs) {
423
+ safeList.push(f);
424
+ }
425
+ }
426
+
427
+ return safeList;
428
+ }
429
+
430
+ function getProjectActivity(targetPath, fallbackLastWriteMs) {
431
+ let current;
432
+ try {
433
+ const isDir = fs.existsSync(targetPath) && fs.statSync(targetPath).isDirectory();
434
+ current = isDir ? path.dirname(path.resolve(targetPath)) : path.dirname(path.resolve(targetPath));
435
+ } catch {
436
+ current = path.dirname(targetPath);
437
+ }
438
+
439
+ let projectRoot = current;
440
+ let lastTouchMs = fallbackLastWriteMs || Date.now();
441
+
442
+ try {
443
+ for (let depth = 0; depth < 4 && current; depth++) {
444
+ if (isProtectedRoot(current)) break;
445
+ const gitDir = path.join(current, '.git');
446
+ if (fs.existsSync(gitDir)) {
447
+ projectRoot = current;
448
+ const headLog = path.join(gitDir, 'logs', 'HEAD');
449
+ const gitIndex = path.join(gitDir, 'index');
450
+ if (fs.existsSync(headLog)) {
451
+ lastTouchMs = fs.statSync(headLog).mtimeMs;
452
+ } else if (fs.existsSync(gitIndex)) {
453
+ lastTouchMs = fs.statSync(gitIndex).mtimeMs;
454
+ } else {
455
+ lastTouchMs = fs.statSync(current).mtimeMs;
456
+ }
457
+ break;
458
+ }
459
+
460
+ const hasMarker =
461
+ fs.existsSync(path.join(current, 'package.json')) ||
462
+ fs.existsSync(path.join(current, 'Cargo.toml')) ||
463
+ fs.existsSync(path.join(current, 'pyproject.toml'));
464
+
465
+ if (hasMarker) {
466
+ projectRoot = current;
467
+ lastTouchMs = fs.statSync(current).mtimeMs;
468
+ break;
469
+ }
470
+
471
+ const parent = path.dirname(current);
472
+ if (parent === current) break;
473
+ current = parent;
474
+ }
475
+ } catch {}
476
+
477
+ const daysUntouched = Math.max(0, Math.floor((Date.now() - lastTouchMs) / (24 * 60 * 60 * 1000)));
478
+ let status = 'ABANDONED';
479
+ if (daysUntouched <= 14) status = 'ACTIVE';
480
+ else if (daysUntouched <= 90) status = 'DORMANT';
481
+
482
+ return { status, daysUntouched, projectRoot };
483
+ }
484
+
485
+ async function recycleItems(paths, dryRun = false) {
486
+ let recycled = 0;
487
+ let failed = 0;
488
+ let protectedSkipped = 0;
489
+ let recycledBytes = 0;
490
+ const recycledPaths = [];
491
+ const validTargets = [];
492
+
493
+ for (const p of paths) {
494
+ if (!p || isProtectedPath(p) || isProtectedRoot(p)) {
495
+ protectedSkipped++;
496
+ continue;
497
+ }
498
+ if (!fs.existsSync(p)) {
499
+ failed++;
500
+ continue;
501
+ }
502
+ try {
503
+ const st = fs.statSync(p);
504
+ const size = st.isDirectory() ? await fastGetDirectorySize(p) : st.size;
505
+ validTargets.push({ path: p, isDir: st.isDirectory(), size });
506
+ } catch {
507
+ failed++;
508
+ }
509
+ }
510
+
511
+ if (dryRun) {
512
+ for (const t of validTargets) {
513
+ recycled++;
514
+ recycledBytes += t.size;
515
+ recycledPaths.push(t.path);
516
+ }
517
+ return { dryRun: true, recycledCount: recycled, recycledBytes, recycledFormatted: formatBytes(recycledBytes), failedCount: failed, protectedSkipped, recycledPaths };
518
+ }
519
+
520
+ if (validTargets.length > 0) {
521
+ if (process.platform === 'win32') {
522
+ // Safe Windows Recycle Bin via Microsoft.VisualBasic.FileIO
523
+ const psScript = `
524
+ Add-Type -AssemblyName Microsoft.VisualBasic
525
+ $items = $env:VACUMIFY_RECYCLE_JSON | ConvertFrom-Json
526
+ foreach ($item in $items) {
527
+ try {
528
+ if ($item.isDir) {
529
+ [Microsoft.VisualBasic.FileIO.FileSystem]::DeleteDirectory($item.path, 'OnlyErrorDialogs', 'SendToRecycleBin')
530
+ } else {
531
+ [Microsoft.VisualBasic.FileIO.FileSystem]::DeleteFile($item.path, 'OnlyErrorDialogs', 'SendToRecycleBin')
532
+ }
533
+ Write-Output "OK:$($item.path)"
534
+ } catch {
535
+ Write-Output "ERR:$($item.path)"
536
+ }
537
+ }
538
+ `;
539
+ const encoded = Buffer.from(psScript, 'utf16le').toString('base64');
540
+ const res = spawnSync('powershell.exe', ['-NoProfile', '-NonInteractive', '-EncodedCommand', encoded], {
541
+ env: { ...process.env, VACUMIFY_RECYCLE_JSON: JSON.stringify(validTargets) },
542
+ encoding: 'utf8'
543
+ });
544
+
545
+ const okSet = new Set();
546
+ if (res.stdout) {
547
+ for (const line of res.stdout.split(/\r?\n/)) {
548
+ if (line.startsWith('OK:')) okSet.add(line.slice(3).trim());
549
+ }
550
+ }
551
+ for (const t of validTargets) {
552
+ if (okSet.has(t.path) || !fs.existsSync(t.path)) {
553
+ recycled++;
554
+ recycledBytes += t.size;
555
+ recycledPaths.push(t.path);
556
+ } else {
557
+ failed++;
558
+ }
559
+ }
560
+ } else if (process.platform === 'darwin') {
561
+ for (const t of validTargets) {
562
+ const res = spawnSync('osascript', ['-e', `tell application "Finder" to delete POSIX file "${t.path.replace(/"/g, '\\"')}"`]);
563
+ if (res.status === 0 && !fs.existsSync(t.path)) {
564
+ recycled++;
565
+ recycledBytes += t.size;
566
+ recycledPaths.push(t.path);
567
+ } else {
568
+ failed++;
569
+ }
570
+ }
571
+ } else {
572
+ for (const t of validTargets) {
573
+ const res = spawnSync('gio', ['trash', t.path]);
574
+ if (res.status === 0 && !fs.existsSync(t.path)) {
575
+ recycled++;
576
+ recycledBytes += t.size;
577
+ recycledPaths.push(t.path);
578
+ } else {
579
+ failed++;
580
+ }
581
+ }
582
+ }
583
+ }
584
+
585
+ return {
586
+ dryRun: false,
587
+ recycledCount: recycled,
588
+ recycledBytes,
589
+ recycledFormatted: formatBytes(recycledBytes),
590
+ failedCount: failed,
591
+ protectedSkipped,
592
+ recycledPaths: recycledPaths.slice(0, 50)
593
+ };
594
+ }
595
+
596
+ module.exports = {
597
+ scanDirectory,
598
+ identifySafeJunk,
599
+ getProjectActivity,
600
+ recycleItems,
601
+ formatBytes,
602
+ formatDate
603
+ };
604
+
package/package.json CHANGED
@@ -1,26 +1,34 @@
1
- {
2
- "name": "vacumify-mcp",
3
- "version": "1.1.0",
4
- "description": "Model Context Protocol (MCP) server for Vacumify — Fast, local-first storage cleaner and duplicate finder for AI agents (Claude Code, Cursor, Antigravity, VS Code)",
5
- "main": "bin/vacumify-mcp.js",
6
- "bin": {
7
- "vacumify-mcp": "bin/vacumify-mcp.js"
8
- },
9
- "keywords": [
10
- "mcp",
11
- "model-context-protocol",
12
- "vacumify",
13
- "disk-cleaner",
14
- "duplicate-finder",
15
- "storage",
16
- "claude",
17
- "cursor",
18
- "ai-agent"
19
- ],
20
- "author": "kuroi17",
21
- "license": "MIT",
22
- "repository": {
23
- "type": "git",
24
- "url": "git+https://github.com/kuroi17/Vacumify.git"
25
- }
26
- }
1
+ {
2
+ "name": "vacumify-mcp",
3
+ "version": "1.2.1",
4
+ "description": "Standalone cross-platform Model Context Protocol (MCP) server for Vacumify — Pure Node.js zero-dependency storage cleaner, duplicate finder, and dev-cache auditor for AI agents (Windows, macOS, Linux)",
5
+ "main": "bin/vacumify-mcp.js",
6
+ "bin": {
7
+ "vacumify-mcp": "bin/vacumify-mcp.js"
8
+ },
9
+ "files": [
10
+ "bin/",
11
+ "lib/",
12
+ "README.md"
13
+ ],
14
+ "engines": {
15
+ "node": ">=18.0.0"
16
+ },
17
+ "keywords": [
18
+ "mcp",
19
+ "model-context-protocol",
20
+ "vacumify",
21
+ "disk-cleaner",
22
+ "duplicate-finder",
23
+ "storage",
24
+ "claude",
25
+ "cursor",
26
+ "ai-agent"
27
+ ],
28
+ "author": "kuroi17",
29
+ "license": "MIT",
30
+ "repository": {
31
+ "type": "git",
32
+ "url": "git+https://github.com/kuroi17/Vacumify.git"
33
+ }
34
+ }