@yagyeshvyas/vibeguard 0.1.0

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.
Files changed (52) hide show
  1. package/README.md +600 -0
  2. package/bin/cli.js +1640 -0
  3. package/ci/vibeguard.yml +41 -0
  4. package/ci-templates/Jenkinsfile +26 -0
  5. package/ci-templates/azure-pipelines.yml +29 -0
  6. package/ci-templates/circleci.yml +24 -0
  7. package/ci-templates/gitlab.yml +19 -0
  8. package/hooks/pre-commit +31 -0
  9. package/package.json +94 -0
  10. package/src/ai-guard.js +205 -0
  11. package/src/ast.js +319 -0
  12. package/src/audit-trail.js +154 -0
  13. package/src/autofix.js +524 -0
  14. package/src/badge.js +42 -0
  15. package/src/behavior.js +205 -0
  16. package/src/compliance.js +151 -0
  17. package/src/crosstaint.js +324 -0
  18. package/src/cve-intel.js +136 -0
  19. package/src/dashboard.js +279 -0
  20. package/src/deps.js +159 -0
  21. package/src/doctor.js +111 -0
  22. package/src/engine.js +234 -0
  23. package/src/external.js +160 -0
  24. package/src/firewall.js +517 -0
  25. package/src/history.js +87 -0
  26. package/src/hook.js +151 -0
  27. package/src/install.js +248 -0
  28. package/src/interceptor.js +476 -0
  29. package/src/mcp-server.js +1804 -0
  30. package/src/net-audit.js +208 -0
  31. package/src/pii.js +212 -0
  32. package/src/plugin.js +80 -0
  33. package/src/policy-gen.js +288 -0
  34. package/src/pre-deploy.js +282 -0
  35. package/src/presets.js +113 -0
  36. package/src/privacy-audit.js +273 -0
  37. package/src/repl.js +150 -0
  38. package/src/report.js +312 -0
  39. package/src/rules-pack.js +2753 -0
  40. package/src/rules.js +1446 -0
  41. package/src/sandbox.js +139 -0
  42. package/src/scanner.js +651 -0
  43. package/src/secure-prompt.js +140 -0
  44. package/src/slopsquat.js +144 -0
  45. package/src/supply-firewall.js +243 -0
  46. package/src/suppress.js +89 -0
  47. package/src/taint.js +168 -0
  48. package/src/trace.js +220 -0
  49. package/src/urlscan.js +142 -0
  50. package/src/vault.js +145 -0
  51. package/src/verify.js +98 -0
  52. package/src/verifykeys.js +87 -0
package/bin/cli.js ADDED
@@ -0,0 +1,1640 @@
1
+ #!/usr/bin/env node
2
+ 'use strict';
3
+
4
+ const fs = require('fs');
5
+ const path = require('path');
6
+ const { scan, computeGrade, sortFindings } = require('../src/scanner');
7
+ const { scanUrl } = require('../src/urlscan');
8
+ const { verify, writeBaseline } = require('../src/verify');
9
+ const {
10
+ computeAutoFixes,
11
+ renderDiff,
12
+ snapshot,
13
+ applyChanges,
14
+ rollback,
15
+ } = require('../src/autofix');
16
+ const {
17
+ renderHuman,
18
+ renderJson,
19
+ renderSarif,
20
+ renderHtml,
21
+ renderFixPrompt,
22
+ C,
23
+ } = require('../src/report');
24
+
25
+ // Flags that take a value (support both --flag=value and --flag value).
26
+ const VALUE_FLAGS = new Set(['fail-on', 'scope', 'focus', 'model', 'since', 'base', 'o', 'output', 'file', 'types']);
27
+
28
+ function parseArgs(argv) {
29
+ const args = { _: [], flags: {} };
30
+ for (let i = 0; i < argv.length; i++) {
31
+ const a = argv[i];
32
+ if (a.startsWith('--')) {
33
+ const eq = a.indexOf('=');
34
+ if (eq !== -1) {
35
+ args.flags[a.slice(2, eq)] = a.slice(eq + 1);
36
+ } else {
37
+ const name = a.slice(2);
38
+ if (VALUE_FLAGS.has(name) && i + 1 < argv.length && !argv[i + 1].startsWith('--')) {
39
+ args.flags[name] = argv[++i];
40
+ } else {
41
+ args.flags[name] = true;
42
+ }
43
+ }
44
+ } else {
45
+ args._.push(a);
46
+ }
47
+ }
48
+ return args;
49
+ }
50
+
51
+ function printHelp() {
52
+ process.stdout.write(`
53
+ VibeGuard — catch common security problems in vibe-coded apps.
54
+
55
+ Usage:
56
+ vibeguard scan [dir] Scan a project and report findings by severity.
57
+ vibeguard fix [dir] List concrete fixes + a copy-paste prompt for your AI.
58
+ vibeguard verify [dir] Re-scan and report which issues are now resolved.
59
+ vibeguard install Wire the MCP server into every detected AI client.
60
+ vibeguard mcp Run the MCP server on stdio (used by AI clients).
61
+ vibeguard rules List every detection rule.
62
+ vibeguard explain <ruleId> Show details + fix for one rule.
63
+ vibeguard doctor [dir] Audit AI-tool host config (hooks, base URL, MCP).
64
+ vibeguard install-hook Install the git pre-commit hook (blocks on CRITICAL).
65
+ vibeguard rollback [dir] Undo the last 'fix --apply' from its snapshot.
66
+ vibeguard watch [dir] Re-scan on every file change (live feedback).
67
+ vibeguard history [dir] Scan git history for secrets (--all for full depth).
68
+ vibeguard url <url> Scan a LIVE site's HTTP response headers/cookies.
69
+ vibeguard badge [dir] Award a badge SVG — only if zero critical & high.
70
+ vibeguard init-ci [dir] Write a GitHub Actions workflow (SARIF + gate).
71
+ vibeguard compliance [dir] Map findings to SOC2/PCI/HIPAA/GDPR/ISO27001/EUAIAct.
72
+ vibeguard cve [dir] Query OSV.dev for known dependency vulnerabilities.
73
+ vibeguard slopsquat [dir] Check for hallucinated/fake npm packages.
74
+ vibeguard secure-prompt <p> Analyze an AI prompt for security risks BEFORE code.
75
+ vibeguard trace [dir] Trace findings to AI prompts + behavior analysis.
76
+ vibeguard repl [dir] Interactive REPL: inspect, solve, ignore findings.
77
+ vibeguard auth-coverage [dir] Enumerate routes → middleware → auth guards.
78
+ vibeguard diff [dir] Compare current scan vs baseline (resolved/new/remaining).
79
+ vibeguard deep-scan [dir] Full audit: scan + CVE + auth + behavior + traces.
80
+ vibeguard html [dir] Generate a self-contained HTML security report.
81
+ vibeguard inject-rules [dir] Inject security rules into CLAUDE.md/.cursorrules/GEMINI.md.
82
+ vibeguard bench [dir] Run a benchmark: files/sec, rules, findings, time.
83
+ vibeguard install-hook-post Install PostToolUse hook (auto-scans after AI edits).
84
+ vibeguard uninstall-hook-post Remove the PostToolUse hook.
85
+ vibeguard hook-post-edit Internal: scan a file after AI edit (called by hook).
86
+ vibeguard risk-score [dir] Quick weighted risk score (0-100) with risk level.
87
+ vibeguard trend [dir] Compare current scan against baseline — show resolved/new.
88
+ vibeguard why <ruleId> Explain why a rule fired and how to fix it.
89
+ vibeguard config-check [dir] Validate VibeGuard configuration and show status.
90
+ vibeguard watch [dir] Watch for file changes and auto-scan on save.
91
+ vibeguard dashboard [dir] Beautiful terminal dashboard with visual charts.
92
+ vibeguard pr-comment [dir] Output GitHub PR comment format (markdown).
93
+ vibeguard preset <name> Apply a rule pack preset (nextjs, django, rails, aws, etc.).
94
+ vibeguard privacy-audit [dir] Inventory all PII collection, storage, and transmission.
95
+ vibeguard net-audit [dir] Map every outbound HTTP call. Flag unknown endpoints.
96
+ vibeguard ai-guard [dir] Detect user data sent to AI APIs without redaction.
97
+ vibeguard privacy-policy [dir] Auto-generate a privacy policy from code analysis.
98
+ vibeguard csp-generate [dir] Auto-generate Content-Security-Policy from code.
99
+ vibeguard firewall <prompt> AI Firewall — inspect a prompt before sending to LLM.
100
+ vibeguard agent-guard [dir] Show agent constraints (blocked paths, commands, domains).
101
+ vibeguard exfil-check <data> Check if data contains PII/secrets before sending externally.
102
+ vibeguard dep-firewall <pkg> Check a package name before npm install (malware/typosquat).
103
+ vibeguard intercept-test [dir] Test runtime interceptor (simulates jailbroken AI).
104
+ vibeguard output-guard <text> Sanitize AI response for PII/secrets before showing to user.
105
+ vibeguard env-lock [dir] Lock environment variables — protect secrets from jailbroken AI.
106
+ vibeguard self-check [dir] Check if VibeGuard itself has been tampered with.
107
+ vibeguard sandbox <code> Execute AI-generated code in zero-trust sandbox.
108
+ vibeguard behavior [dir] Behavioral analysis of AI agent patterns.
109
+ vibeguard supply-firewall [dir] Supply chain audit: lockfile, scripts, licenses.
110
+ vibeguard vault <action> Secret vault: store, list, log (encrypted in-memory).
111
+ vibeguard audit-trail [action] Tamper-proof audit trail: show, export, verify.
112
+ vibeguard pre-deploy [dir] Run ALL 13 security gates before deployment.
113
+ Use --strict to fail on warnings, --json for CI/CD.
114
+ vibeguard preset --list List all available presets.
115
+ vibeguard redact "<text>" Redact personal data (email/SSN/card/phone/…) from text.
116
+ vibeguard detect-pii "<text>" List personal data found in text (no redaction).
117
+
118
+ Options:
119
+ --json Output machine-readable JSON.
120
+ --sarif Output SARIF 2.1.0 (for CI / GitHub code scanning).
121
+ --fix-prompt Print only the paste-back "fix prompt" block.
122
+ --apply (fix) Apply safe auto-fixes (snapshotted; default is dry-run).
123
+ --local (install) Point clients at this checkout, not npx.
124
+ --baseline (scan) Save a baseline for later 'verify'.
125
+ --no-deps (scan) Skip the npm/pip dependency audit.
126
+ --deep (scan) Fold in semgrep/gitleaks/bandit if installed.
127
+ --new-only (scan) Report only findings not in the saved baseline.
128
+ --verify-keys (scan) Ping providers to confirm found keys are LIVE (opt-in).
129
+ --fail-on <level> (scan) Exit non-zero only at/above this severity (critical..low/none).
130
+ --precommit Exit non-zero only on CRITICAL findings (hook mode).
131
+ --no-summary Suppress the trailing summary line.
132
+ --patch Output findings as a unified diff (git-apply format).
133
+ -o, --output <file> (html) Output file path for HTML report.
134
+ -h, --help Show this help.
135
+
136
+ Scope: VibeGuard flags high-frequency, well-defined issues (secrets, injection,
137
+ misconfig) and helps you fix them. It does NOT prove an app is safe and cannot
138
+ catch every logic bug or backdoor.
139
+ `);
140
+ }
141
+
142
+ function outputResult(result, flags) {
143
+ if (flags.json) {
144
+ process.stdout.write(renderJson(result) + '\n');
145
+ return;
146
+ }
147
+ if (flags.sarif) {
148
+ process.stdout.write(renderSarif(result) + '\n');
149
+ return;
150
+ }
151
+ if (flags['fix-prompt']) {
152
+ process.stdout.write(renderFixPrompt(result) + '\n');
153
+ return;
154
+ }
155
+ if (flags['patch']) {
156
+ const patches = generatePatch(result.findings);
157
+ process.stdout.write(patches);
158
+ return;
159
+ }
160
+ process.stdout.write(renderHuman(result));
161
+ }
162
+
163
+ function cmdScan(dir, flags) {
164
+ // Dependency audit runs by default; disable with --no-deps.
165
+ // --deep folds in external scanners (semgrep/gitleaks) when installed.
166
+ const result = scan(dir, {
167
+ deps: flags.deps !== false && !flags['no-deps'],
168
+ deep: !!flags.deep,
169
+ });
170
+ // --new-only: report only findings not present in the saved baseline.
171
+ if (flags['new-only']) {
172
+ const { readBaseline } = require('../src/verify');
173
+ const base = readBaseline(dir);
174
+ if (base && Array.isArray(base.findings)) {
175
+ const seen = new Set(
176
+ base.findings.map((f) => f.fingerprint || `${f.ruleId} ${f.file} ${(f.snippet || '').trim()}`)
177
+ );
178
+ result.findings = result.findings.filter((f) => !seen.has(f.fingerprint));
179
+ const { computeGrade } = require('../src/scanner');
180
+ const g = computeGrade(result.findings);
181
+ result.grade = g.grade;
182
+ result.counts = g.counts;
183
+ }
184
+ }
185
+
186
+ if (flags.deep && result.externalInfo && !flags.json && !flags.sarif) {
187
+ const ran = result.externalInfo.ran || {};
188
+ process.stderr.write(
189
+ `${C.dim}deep: semgrep=${ran.semgrep ? 'ran' : 'skipped'}, gitleaks=${ran.gitleaks ? 'ran' : 'skipped'}` +
190
+ (result.externalInfo.notes.length ? ' (' + result.externalInfo.notes.join('; ') + ')' : '') +
191
+ `${C.reset}\n`
192
+ );
193
+ }
194
+ if (flags.baseline) {
195
+ const p = writeBaseline(dir, result);
196
+ if (!flags.json && !flags.sarif) {
197
+ process.stderr.write(`${C.dim}baseline saved: ${p}${C.reset}\n`);
198
+ }
199
+ }
200
+ outputResult(result, flags);
201
+
202
+ if (flags.precommit) {
203
+ // Hook mode: block only on CRITICAL.
204
+ return result.counts.critical > 0 ? 2 : 0;
205
+ }
206
+ // --fail-on <level>: exit 1 only when a finding at/above that severity exists.
207
+ if (flags['fail-on']) {
208
+ const order = ['critical', 'high', 'medium', 'low'];
209
+ const threshold = order.indexOf(String(flags['fail-on']).toLowerCase());
210
+ if (String(flags['fail-on']).toLowerCase() === 'none') return 0;
211
+ if (threshold === -1) return result.findings.length > 0 ? 1 : 0;
212
+ const worst = result.findings.reduce((acc, f) => Math.min(acc, order.indexOf(f.severity)), 4);
213
+ return worst <= threshold ? 1 : 0;
214
+ }
215
+ // Default exit: non-zero if any finding, so CI notices.
216
+ return result.findings.length > 0 ? 1 : 0;
217
+ }
218
+
219
+ function cmdFix(dir, flags) {
220
+ const result = scan(dir);
221
+
222
+ if (flags.json) {
223
+ process.stdout.write(renderJson(result) + '\n');
224
+ return result.findings.length > 0 ? 1 : 0;
225
+ }
226
+
227
+ // fix NEVER rewrites files silently. It prints the concrete fixes plus a
228
+ // ready-to-paste prompt for the user's AI tool to apply under review.
229
+ if (result.findings.length === 0) {
230
+ process.stdout.write(`${C.green}Nothing to fix — no issues found.${C.reset}\n`);
231
+ return 0;
232
+ }
233
+
234
+ process.stdout.write(renderHuman(result));
235
+
236
+ // Safe auto-fixes: dry-run diff by default; apply only with --apply (snapshotted).
237
+ const changes = computeAutoFixes(dir, result);
238
+ if (changes.length > 0) {
239
+ process.stdout.write(
240
+ `${C.bold}${C.cyan}Safe auto-fixes available (${changes.length}) — mechanical & reversible:${C.reset}\n\n`
241
+ );
242
+ for (const c of changes) {
243
+ process.stdout.write(`${C.bold}${c.description}${C.reset} ${C.dim}[${c.ruleId}]${C.reset}\n`);
244
+ process.stdout.write(renderDiff(c) + '\n\n');
245
+ }
246
+ if (flags.apply) {
247
+ const snapDir = snapshot(dir, changes);
248
+ applyChanges(dir, changes);
249
+ process.stdout.write(
250
+ `${C.green}Applied ${changes.length} safe fix(es).${C.reset} ` +
251
+ `${C.dim}Snapshot: ${snapDir}${C.reset}\n` +
252
+ `Undo with: ${C.bold}vibeguard rollback ${dir}${C.reset}\n\n`
253
+ );
254
+ } else {
255
+ process.stdout.write(
256
+ `${C.yellow}Dry run — nothing written.${C.reset} Apply these with: ` +
257
+ `${C.bold}vibeguard fix ${dir} --apply${C.reset} (files are snapshotted first).\n\n`
258
+ );
259
+ }
260
+ }
261
+
262
+ process.stdout.write(
263
+ `${C.bold}${C.cyan}Copy-paste this into your AI coding tool to apply the remaining fixes:${C.reset}\n`
264
+ );
265
+ process.stdout.write(`${C.dim}${'-'.repeat(70)}${C.reset}\n`);
266
+ process.stdout.write(renderFixPrompt(result) + '\n');
267
+ process.stdout.write(`${C.dim}${'-'.repeat(70)}${C.reset}\n`);
268
+ process.stdout.write(
269
+ `\n${C.yellow}Review every change before committing. VibeGuard will not edit your files for you.${C.reset}\n`
270
+ );
271
+ process.stdout.write(
272
+ `${C.dim}Tip: run 'vibeguard scan --baseline' first, then 'vibeguard verify' after fixing.${C.reset}\n`
273
+ );
274
+ return result.findings.length > 0 ? 1 : 0;
275
+ }
276
+
277
+ function cmdVerify(dir, flags) {
278
+ const res = verify(dir);
279
+
280
+ if (flags.json) {
281
+ process.stdout.write(
282
+ JSON.stringify(
283
+ {
284
+ hasBaseline: res.hasBaseline,
285
+ grade: res.current.grade,
286
+ counts: res.current.counts,
287
+ resolved: res.resolved,
288
+ remaining: res.remaining,
289
+ introduced: res.introduced,
290
+ },
291
+ null,
292
+ 2
293
+ ) + '\n'
294
+ );
295
+ return res.remaining.length + res.introduced.length > 0 ? 1 : 0;
296
+ }
297
+
298
+ process.stdout.write(`\n${C.bold}${C.cyan}VibeGuard verify${C.reset}\n\n`);
299
+
300
+ if (!res.hasBaseline) {
301
+ process.stdout.write(
302
+ `${C.yellow}No baseline found.${C.reset} Showing current state. ` +
303
+ `Run 'vibeguard scan --baseline' before fixing to enable a before/after diff.\n\n`
304
+ );
305
+ outputResult(res.current, {});
306
+ return res.current.findings.length > 0 ? 1 : 0;
307
+ }
308
+
309
+ for (const f of res.resolved) {
310
+ process.stdout.write(
311
+ `${C.green}✓ resolved${C.reset} ${f.file}:${f.line} ${C.dim}[${f.ruleId}]${C.reset}\n`
312
+ );
313
+ }
314
+ for (const f of res.remaining) {
315
+ process.stdout.write(
316
+ `${C.red}✗ still present${C.reset} ${f.file}:${f.line} ${C.dim}[${f.ruleId}]${C.reset}\n`
317
+ );
318
+ }
319
+ for (const f of res.introduced) {
320
+ process.stdout.write(
321
+ `${C.magenta}! new issue${C.reset} ${f.file}:${f.line} ${C.dim}[${f.ruleId}]${C.reset}\n`
322
+ );
323
+ }
324
+
325
+ process.stdout.write(
326
+ `\n${C.bold}${res.resolved.length} resolved${C.reset}, ` +
327
+ `${res.remaining.length} remaining, ${res.introduced.length} new. ` +
328
+ `Current grade: ${res.current.grade}\n\n`
329
+ );
330
+
331
+ return res.remaining.length + res.introduced.length > 0 ? 1 : 0;
332
+ }
333
+
334
+ function cmdWatch(dir, flags) {
335
+ const runScan = () => {
336
+ const result = scan(dir, { deps: false });
337
+ process.stdout.write('\x1b[2J\x1b[H'); // clear screen
338
+ process.stdout.write(renderHuman(result));
339
+ };
340
+ process.stdout.write(`${C.cyan}VibeGuard watching ${path.resolve(dir)} — Ctrl+C to stop${C.reset}\n`);
341
+ runScan();
342
+ let timer = null;
343
+ const debounced = (_e, file) => {
344
+ if (file && /node_modules|\.git|\.vibeguard/.test(String(file))) return;
345
+ clearTimeout(timer);
346
+ timer = setTimeout(runScan, 300);
347
+ };
348
+ try {
349
+ fs.watch(path.resolve(dir), { recursive: true }, debounced);
350
+ } catch (err) {
351
+ process.stderr.write(`watch not supported here: ${err.message}\n`);
352
+ return 2;
353
+ }
354
+ return new Promise(() => {}); // never resolves; runs until Ctrl+C
355
+ }
356
+
357
+ async function cmdUrl(target, flags) {
358
+ if (!target || target === '.') {
359
+ process.stderr.write('usage: vibeguard url <https://your-site.com>\n');
360
+ return 2;
361
+ }
362
+ let res;
363
+ try {
364
+ res = await scanUrl(target);
365
+ } catch (err) {
366
+ process.stderr.write(`vibeguard url error: ${err.message}\n`);
367
+ return 2;
368
+ }
369
+ const findings = sortFindings(res.findings);
370
+ const { grade, counts } = computeGrade(findings);
371
+ const result = {
372
+ root: res.url,
373
+ scannedFiles: 1,
374
+ findings,
375
+ grade,
376
+ counts,
377
+ generatedAt: new Date().toISOString(),
378
+ };
379
+ outputResult(result, flags);
380
+ return findings.length > 0 ? 1 : 0;
381
+ }
382
+
383
+ function cmdRules(flags) {
384
+ const { allRules } = require('../src/rules');
385
+ const rules = allRules().sort((a, b) => (a.category + a.id).localeCompare(b.category + b.id));
386
+ if (flags.json) {
387
+ process.stdout.write(JSON.stringify(rules, null, 2) + '\n');
388
+ return 0;
389
+ }
390
+ let cat = '';
391
+ for (const r of rules) {
392
+ if (r.category !== cat) { cat = r.category; process.stdout.write(`\n${C.bold}${C.cyan}${cat}${C.reset}\n`); }
393
+ process.stdout.write(` ${r.id.padEnd(34)} ${C.dim}${r.severity}${C.reset} ${r.title}\n`);
394
+ }
395
+ process.stdout.write(`\n${C.dim}${rules.length} rules. 'vibeguard explain <ruleId>' for details.${C.reset}\n`);
396
+ return 0;
397
+ }
398
+
399
+ function cmdExplain(ruleId, flags) {
400
+ const { allRules } = require('../src/rules');
401
+ const r = allRules().find((x) => x.id === ruleId);
402
+ if (!r) {
403
+ process.stderr.write(`Unknown rule: ${ruleId}. Run 'vibeguard rules' to list them.\n`);
404
+ return 2;
405
+ }
406
+ if (flags.json) { process.stdout.write(JSON.stringify(r, null, 2) + '\n'); return 0; }
407
+ process.stdout.write(
408
+ `\n${C.bold}${r.id}${C.reset} ${C.dim}[${r.category}]${C.reset}\n` +
409
+ `severity: ${r.severity} confidence: ${r.confidence}\n` +
410
+ `${C.bold}${r.title}${C.reset}\n\n` +
411
+ (r.message ? r.message + '\n\n' : '') +
412
+ (r.fix ? `${C.green}fix:${C.reset} ${r.fix}\n` : `${C.dim}(dynamic message — run a scan to see specifics)${C.reset}\n`)
413
+ );
414
+ return 0;
415
+ }
416
+
417
+ function cmdDoctor(dir, flags) {
418
+ const { runDoctor } = require('../src/doctor');
419
+ const findings = runDoctor(dir, { scope: flags.scope || 'full' });
420
+ if (flags.json) { process.stdout.write(JSON.stringify({ findings }, null, 2) + '\n'); return findings.length ? 1 : 0; }
421
+ process.stdout.write(`\n${C.bold}${C.cyan}VibeGuard doctor${C.reset} ${C.dim}(AI host security)${C.reset}\n\n`);
422
+ if (findings.length === 0) {
423
+ process.stdout.write(`${C.green}No host security issues found in AI tool configs / environment.${C.reset}\n`);
424
+ return 0;
425
+ }
426
+ for (const f of findings) {
427
+ process.stdout.write(`${C.red}${f.severity.toUpperCase()}${C.reset} ${f.file} ${C.dim}[${f.ruleId}]${C.reset}\n ${f.message}\n ${C.green}fix:${C.reset} ${f.fix}\n\n`);
428
+ }
429
+ process.stdout.write(`${C.bold}${findings.length} host issue(s).${C.reset} These affect your machine/AI tools, not just this repo.\n`);
430
+ return 1;
431
+ }
432
+
433
+ function cmdHistory(dir, flags) {
434
+ const { scanHistory } = require('../src/history');
435
+ const res = scanHistory(dir, { all: !!flags.all });
436
+ if (!res.ran) {
437
+ process.stderr.write(`${C.yellow}${res.note}${C.reset}\n`);
438
+ return 2;
439
+ }
440
+ if (flags.json) {
441
+ process.stdout.write(JSON.stringify({ findings: res.findings }, null, 2) + '\n');
442
+ return res.findings.length ? 1 : 0;
443
+ }
444
+ if (res.findings.length === 0) {
445
+ process.stdout.write(`${C.green}No secrets found in git history (scanned recent commits).${C.reset}\n`);
446
+ return 0;
447
+ }
448
+ process.stdout.write(`\n${C.bold}${C.red}Secrets found in git history:${C.reset}\n\n`);
449
+ for (const f of res.findings) {
450
+ process.stdout.write(`${C.red}CRITICAL${C.reset} ${f.file}:${f.line} ${C.dim}[${f.ruleId}]${C.reset}\n ${f.message}\n ${C.green}fix:${C.reset} ${f.fix}\n\n`);
451
+ }
452
+ process.stdout.write(`${C.bold}${res.findings.length} secret(s) in history.${C.reset} Rotate them — removing the file does NOT remove them from git.\n`);
453
+ return 1;
454
+ }
455
+
456
+ function cmdRollback(dir) {
457
+ const res = rollback(dir);
458
+ if (!res.ok) {
459
+ process.stderr.write(`${C.yellow}Nothing to roll back:${C.reset} ${res.reason}\n`);
460
+ return 1;
461
+ }
462
+ process.stdout.write(
463
+ `${C.green}Rolled back ${res.restored.length} file(s)${C.reset} from snapshot ${res.stamp}:\n` +
464
+ res.restored.map((f) => ` ${f}`).join('\n') +
465
+ '\n'
466
+ );
467
+ return 0;
468
+ }
469
+
470
+ function cmdInstall(flags) {
471
+ const { install } = require('../src/install');
472
+ const { spec, results, paste } = install({ local: !!flags.local });
473
+
474
+ process.stdout.write(`\n${C.bold}${C.cyan}VibeGuard — wiring the MCP server into your AI tools${C.reset}\n`);
475
+ process.stdout.write(`${C.dim}server: ${spec.command} ${spec.args.join(' ')}${C.reset}\n\n`);
476
+
477
+ const icon = { installed: `${C.green}✓${C.reset}`, skipped: `${C.dim}–${C.reset}`, manual: `${C.yellow}!${C.reset}`, error: `${C.red}✗${C.reset}` };
478
+ for (const r of results) {
479
+ process.stdout.write(` ${icon[r.status] || '?'} ${r.client.padEnd(14)} ${C.dim}${r.detail}${C.reset}\n`);
480
+ }
481
+
482
+ const installed = results.filter((r) => r.status === 'installed').length;
483
+ process.stdout.write(
484
+ `\n${C.bold}${installed} client(s) wired.${C.reset} Restart the client to pick up the server.\n`
485
+ );
486
+ process.stdout.write(
487
+ `\n${C.dim}For any client not listed (Antigravity, Gemini CLI, JetBrains, …), paste this into its MCP config:${C.reset}\n`
488
+ );
489
+ process.stdout.write(paste + '\n');
490
+ if (!flags.local) {
491
+ process.stdout.write(
492
+ `\n${C.dim}Tip: add --local to point clients at this checkout instead of npx (for dev/testing before publish).${C.reset}\n`
493
+ );
494
+ }
495
+ return 0;
496
+ }
497
+
498
+ function cmdBadge(dir, flags) {
499
+ const badge = require('../src/badge');
500
+ const result = scan(dir, { deps: flags.deps !== false && !flags['no-deps'] });
501
+ const date = new Date().toISOString().slice(0, 10);
502
+
503
+ if (!badge.isEligible(result)) {
504
+ process.stderr.write(
505
+ `${C.yellow}No badge awarded.${C.reset} A badge requires zero critical and zero high findings.\n` +
506
+ `Current grade ${result.grade}: ${result.counts.critical} critical, ${result.counts.high} high. ` +
507
+ `Fix those, then run 'vibeguard badge' again.\n`
508
+ );
509
+ return 1;
510
+ }
511
+
512
+ const svgPath = path.join(path.resolve(dir), 'vibeguard-badge.svg');
513
+ fs.writeFileSync(svgPath, badge.svg(result, date));
514
+ const md = badge.markdown(result, date, './vibeguard-badge.svg');
515
+
516
+ if (flags.json) {
517
+ process.stdout.write(
518
+ JSON.stringify({ eligible: true, date, grade: result.grade, svg: svgPath, markdown: md }, null, 2) + '\n'
519
+ );
520
+ return 0;
521
+ }
522
+ process.stdout.write(
523
+ `${C.green}Badge awarded${C.reset} — ${badge.passLabel(date)}.\n` +
524
+ `SVG written to ${svgPath}\n\n` +
525
+ `Add to your README:\n ${md}\n\n` +
526
+ `${C.dim}This attests the project passed VibeGuard's checks on ${date}. It is not a` +
527
+ ` guarantee of safety.${C.reset}\n`
528
+ );
529
+ return 0;
530
+ }
531
+
532
+ function cmdInitCi(dir) {
533
+ const root = path.resolve(dir);
534
+ const wfDir = path.join(root, '.github', 'workflows');
535
+ fs.mkdirSync(wfDir, { recursive: true });
536
+ const dest = path.join(wfDir, 'vibeguard.yml');
537
+ if (fs.existsSync(dest)) {
538
+ process.stderr.write(`${dest} already exists — not overwriting.\n`);
539
+ return 2;
540
+ }
541
+ const src = path.join(__dirname, '..', 'ci', 'vibeguard.yml');
542
+ fs.copyFileSync(src, dest);
543
+ process.stdout.write(
544
+ `${C.green}Wrote GitHub Actions workflow${C.reset} to ${dest}\n` +
545
+ `${C.dim}It uploads SARIF to code scanning and fails the build on CRITICAL findings.${C.reset}\n`
546
+ );
547
+ return 0;
548
+ }
549
+
550
+ function cmdInstallHook(dir) {
551
+ const root = path.resolve(dir);
552
+ const gitDir = path.join(root, '.git');
553
+ if (!fs.existsSync(gitDir)) {
554
+ process.stderr.write(
555
+ `error: ${root} is not a git repository (no .git). Run 'git init' first.\n`
556
+ );
557
+ return 2;
558
+ }
559
+ const hooksDir = path.join(gitDir, 'hooks');
560
+ fs.mkdirSync(hooksDir, { recursive: true });
561
+ const dest = path.join(hooksDir, 'pre-commit');
562
+
563
+ if (fs.existsSync(dest)) {
564
+ const existing = fs.readFileSync(dest, 'utf8');
565
+ if (!existing.includes('VibeGuard pre-commit hook')) {
566
+ process.stderr.write(
567
+ `A pre-commit hook already exists at ${dest}.\n` +
568
+ `Refusing to overwrite it. Merge in hooks/pre-commit manually.\n`
569
+ );
570
+ return 2;
571
+ }
572
+ }
573
+
574
+ // Bake in the absolute path to THIS CLI so the hook always finds the scanner,
575
+ // and fail LOUD (block) if it can't run — a security hook must never pass
576
+ // silently just because the tool is missing.
577
+ const cliPath = path.resolve(__dirname, 'cli.js');
578
+ const nodeBin = process.execPath;
579
+ const hook = `#!/usr/bin/env sh
580
+ # VibeGuard pre-commit hook (generated by 'vibeguard install-hook').
581
+ # Blocks the commit ONLY when a CRITICAL issue is found. Bypass: git commit --no-verify
582
+ NODE="${nodeBin.split('\\').join('/')}"
583
+ CLI="${cliPath.split('\\').join('/')}"
584
+ if [ ! -x "$NODE" ]; then NODE=node; fi
585
+ if [ ! -f "$CLI" ]; then
586
+ echo "VibeGuard: scanner not found at $CLI — commit blocked (fail-closed). Reinstall the hook."
587
+ exit 1
588
+ fi
589
+ "$NODE" "$CLI" scan . --precommit
590
+ STATUS=$?
591
+ if [ "$STATUS" -eq 2 ]; then
592
+ echo ""
593
+ echo "VibeGuard: commit blocked — CRITICAL security issue(s) found above."
594
+ echo "Fix them, or bypass intentionally with: git commit --no-verify"
595
+ exit 1
596
+ fi
597
+ exit 0
598
+ `;
599
+ fs.writeFileSync(dest, hook);
600
+ try {
601
+ fs.chmodSync(dest, 0o755);
602
+ } catch {
603
+ /* chmod is a no-op / may fail on Windows — git uses core.fileMode there */
604
+ }
605
+ process.stdout.write(
606
+ `${C.green}Installed pre-commit hook${C.reset} at ${dest}\n` +
607
+ `${C.dim}It blocks commits only when a CRITICAL issue is found.${C.reset}\n`
608
+ );
609
+ return 0;
610
+ }
611
+
612
+ async function main() {
613
+ const argv = process.argv.slice(2);
614
+ const args = parseArgs(argv);
615
+ const flags = args.flags;
616
+
617
+ if (flags.help || flags.h || args._[0] === 'help') {
618
+ printHelp();
619
+ process.exit(0);
620
+ }
621
+
622
+ const cmd = args._[0] || 'scan';
623
+ const dir = args._[1] || '.';
624
+
625
+ const noDirCmds = new Set(['url', 'rules', 'explain', 'secure-prompt', 'redact', 'detect-pii', 'firewall', 'exfil-check', 'dep-firewall', 'sandbox', 'output-guard', 'vault', 'audit-trail', 'why']);
626
+ if (!noDirCmds.has(cmd) && !fs.existsSync(dir)) {
627
+ process.stderr.write(`error: directory not found: ${dir}\n`);
628
+ process.exit(2);
629
+ }
630
+
631
+ // MCP server mode: hand off to the server (it runs until stdin closes).
632
+ // This is what `npx -y @yagyeshvyas/vibeguard mcp` starts inside Claude Code / Cursor / etc.
633
+ if (cmd === 'mcp') {
634
+ require('../src/mcp-server.js');
635
+ return; // do NOT process.exit — the server owns the process lifetime
636
+ }
637
+
638
+ // scan --verify-keys: async provider probing.
639
+ if (cmd === 'scan' && flags['verify-keys']) {
640
+ (async () => {
641
+ const result = scan(dir, { deps: flags.deps !== false && !flags['no-deps'], deep: !!flags.deep });
642
+ try {
643
+ const { verifyKeys } = require('../src/verifykeys');
644
+ const live = await verifyKeys(dir, result.findings);
645
+ if (live > 0 && !flags.json && !flags.sarif) {
646
+ process.stderr.write(`${C.red}${live} key(s) CONFIRMED LIVE.${C.reset}\n`);
647
+ }
648
+ } catch (err) {
649
+ process.stderr.write(`verify-keys error: ${err.message}\n`);
650
+ }
651
+ const { computeGrade } = require('../src/scanner');
652
+ const g = computeGrade(result.findings);
653
+ result.grade = g.grade;
654
+ result.counts = g.counts;
655
+ outputResult(result, flags);
656
+ process.exit(result.counts.critical > 0 ? 2 : result.findings.length > 0 ? 1 : 0);
657
+ })().catch((err) => {
658
+ process.stderr.write(`vibeguard error: ${err.message}\n`);
659
+ process.exit(2);
660
+ });
661
+ return;
662
+ }
663
+
664
+ // Watch mode (long-running).
665
+ if (cmd === 'watch') {
666
+ Promise.resolve(cmdWatch(dir, flags)).catch((err) => {
667
+ process.stderr.write(`vibeguard error: ${err && err.message ? err.message : err}\n`);
668
+ process.exit(2);
669
+ });
670
+ return;
671
+ }
672
+
673
+ // Async command: live URL scan.
674
+ if (cmd === 'url') {
675
+ cmdUrl(args._[1], flags)
676
+ .then((c) => process.exit(c))
677
+ .catch((err) => {
678
+ process.stderr.write(`vibeguard error: ${err && err.message ? err.message : err}\n`);
679
+ process.exit(2);
680
+ });
681
+ return;
682
+ }
683
+
684
+ let code = 0;
685
+ try {
686
+ if (cmd === 'scan') code = cmdScan(dir, flags);
687
+ else if (cmd === 'fix') code = cmdFix(dir, flags);
688
+ else if (cmd === 'verify') code = cmdVerify(dir, flags);
689
+ else if (cmd === 'install-hook') code = cmdInstallHook(dir);
690
+ else if (cmd === 'rollback') code = cmdRollback(dir);
691
+ else if (cmd === 'history') code = cmdHistory(dir, flags);
692
+ else if (cmd === 'badge') code = cmdBadge(dir, flags);
693
+ else if (cmd === 'init-ci') code = cmdInitCi(dir);
694
+ else if (cmd === 'install') code = cmdInstall(flags);
695
+ else if (cmd === 'rules') code = cmdRules(flags);
696
+ else if (cmd === 'explain') code = cmdExplain(args._[1], flags);
697
+ else if (cmd === 'doctor') code = cmdDoctor(dir, flags);
698
+ else if (cmd === 'compliance') code = cmdCompliance(dir, flags);
699
+ else if (cmd === 'cve') code = await cmdCve(dir, flags);
700
+ else if (cmd === 'slopsquat') code = await cmdSlopsquat(dir, flags);
701
+ else if (cmd === 'secure-prompt') code = cmdSecurePrompt(args._[1] || '.', flags);
702
+ else if (cmd === 'trace') code = cmdTrace(dir, flags);
703
+ else if (cmd === 'repl') code = await cmdRepl(dir, flags);
704
+ else if (cmd === 'auth-coverage') code = cmdAuthCoverage(dir, flags);
705
+ else if (cmd === 'diff') code = cmdDiff(dir, flags);
706
+ else if (cmd === 'deep-scan') code = await cmdDeepScan(dir, flags);
707
+ else if (cmd === 'html') code = cmdHtml(dir, flags);
708
+ else if (cmd === 'inject-rules') code = cmdInjectRules(dir, flags);
709
+ else if (cmd === 'bench') code = cmdBench(dir, flags);
710
+ else if (cmd === 'hook-post-edit') { require('../src/hook').handlePostEdit(); return; }
711
+ else if (cmd === 'install-hook-post') { const r = require('../src/hook').installPostEditHook(dir); process.stdout.write(r.installed ? `Installed PostToolUse hook in ${r.file}\n` : `Hook ${r.reason}\n`); code = 0; }
712
+ else if (cmd === 'uninstall-hook-post') { const r = require('../src/hook').uninstallPostEditHook(dir); process.stdout.write(r.uninstalled ? 'Uninstalled.\n' : `Not found: ${r.reason}\n`); code = 0; }
713
+ else if (cmd === 'risk-score') code = cmdRiskScore(dir, flags);
714
+ else if (cmd === 'trend') code = cmdTrend(dir, flags);
715
+ else if (cmd === 'why') code = cmdWhy(dir, args, flags);
716
+ else if (cmd === 'config-check') code = cmdConfigCheck(dir, flags);
717
+ else if (cmd === 'watch') code = cmdWatch(dir, flags);
718
+ else if (cmd === 'dashboard') code = cmdDashboard(dir, flags);
719
+ else if (cmd === 'pr-comment') code = cmdPRComment(dir, flags);
720
+ else if (cmd === 'preset') code = cmdPreset(dir, args, flags);
721
+ else if (cmd === 'privacy-audit') code = cmdPrivacyAudit(dir, flags);
722
+ else if (cmd === 'net-audit') code = cmdNetAudit(dir, flags);
723
+ else if (cmd === 'ai-guard') code = cmdAIGuard(dir, flags);
724
+ else if (cmd === 'privacy-policy') code = cmdPrivacyPolicy(dir, flags);
725
+ else if (cmd === 'csp-generate') code = cmdCSPGenerate(dir, flags);
726
+ else if (cmd === 'firewall') code = cmdFirewall(args, flags);
727
+ else if (cmd === 'agent-guard') code = cmdAgentGuard(dir, flags);
728
+ else if (cmd === 'exfil-check') code = cmdExfilCheck(args, flags);
729
+ else if (cmd === 'dep-firewall') code = cmdDepFirewall(args, flags);
730
+ else if (cmd === 'intercept-test') code = cmdInterceptTest(dir, args, flags);
731
+ else if (cmd === 'output-guard') code = cmdOutputGuard(args, flags);
732
+ else if (cmd === 'env-lock') code = cmdEnvLock(dir, flags);
733
+ else if (cmd === 'self-check') code = cmdSelfCheck(dir, flags);
734
+ else if (cmd === 'sandbox') code = cmdSandbox(args, flags);
735
+ else if (cmd === 'behavior') code = cmdBehavior(dir, flags);
736
+ else if (cmd === 'supply-firewall') code = cmdSupplyFirewall(dir, flags);
737
+ else if (cmd === 'vault') code = cmdVault(args, flags);
738
+ else if (cmd === 'audit-trail') code = cmdAuditTrail(args, flags);
739
+ else if (cmd === 'pre-deploy') code = cmdPreDeploy(dir, flags);
740
+ else if (cmd === 'redact') code = cmdRedact(args, flags);
741
+ else if (cmd === 'detect-pii') code = cmdDetectPII(args, flags);
742
+ else {
743
+ process.stderr.write(`unknown command: ${cmd}\n`);
744
+ printHelp();
745
+ code = 2;
746
+ }
747
+ } catch (err) {
748
+ process.stderr.write(`vibeguard error: ${err && err.message ? err.message : err}\n`);
749
+ code = 2;
750
+ }
751
+ process.exit(code);
752
+ }
753
+
754
+ function generatePatch(findings) {
755
+ const lines = [];
756
+ for (const f of findings) {
757
+ if (!f.fix) continue;
758
+ lines.push(`--- a/${f.file}`);
759
+ lines.push(`+++ b/${f.file}`);
760
+ lines.push(`@@ -${f.line},1 +${f.line},1 @@`);
761
+ lines.push(`- ${f.snippet || ''}`);
762
+ lines.push(`+ # vibeguard: ${f.ruleId} — ${f.fix}`);
763
+ lines.push('');
764
+ }
765
+ return lines.join('\n');
766
+ }
767
+
768
+ // --- NEW COMMAND HANDLERS ---
769
+
770
+ function cmdCompliance(dir, flags) {
771
+ const { scan } = require('../src/scanner');
772
+ const result = scan(dir);
773
+ const { generateComplianceReport } = require('../src/compliance');
774
+ const report = generateComplianceReport(result.findings, flags.framework);
775
+ process.stdout.write(JSON.stringify(report, null, 2) + '\n');
776
+ return 0;
777
+ }
778
+
779
+ async function cmdCve(dir, flags) {
780
+ const { scanCVEs } = require('../src/cve-intel');
781
+ const result = await scanCVEs(dir);
782
+ if (flags.json) {
783
+ process.stdout.write(JSON.stringify(result, null, 2) + '\n');
784
+ } else {
785
+ process.stdout.write(`Checked ${result.checked} packages. ${result.findings.length} vulnerabilities.\n`);
786
+ for (const f of result.findings) {
787
+ process.stdout.write(` ${C.red}${f.severity}${C.reset} ${f.title}\n ${f.message}\n ${C.green}fix:${C.reset} ${f.fix}\n\n`);
788
+ }
789
+ }
790
+ return result.findings.length > 0 ? 1 : 0;
791
+ }
792
+
793
+ async function cmdSlopsquat(dir, flags) {
794
+ const { walk } = require('../src/scanner');
795
+ const files = walk(dir, []);
796
+ const { scanSlopsquat } = require('../src/slopsquat');
797
+ const result = await scanSlopsquat(dir, files);
798
+ if (flags.json) {
799
+ process.stdout.write(JSON.stringify(result, null, 2) + '\n');
800
+ } else {
801
+ process.stdout.write(`Checked ${result.checked} imports. ${result.findings.length} suspicious packages.\n`);
802
+ for (const f of result.findings) {
803
+ process.stdout.write(` ${C.yellow}${f.title}${C.reset}\n ${f.message}\n ${C.green}fix:${C.reset} ${f.fix}\n\n`);
804
+ }
805
+ }
806
+ return result.findings.length > 0 ? 1 : 0;
807
+ }
808
+
809
+ function cmdSecurePrompt(promptText, flags) {
810
+ if (!promptText || promptText === '.') {
811
+ process.stderr.write('usage: vibeguard secure-prompt "your prompt text here"\n');
812
+ return 2;
813
+ }
814
+ const { analyzePrompt } = require('../src/secure-prompt');
815
+ const result = analyzePrompt(promptText);
816
+ if (flags.json) {
817
+ process.stdout.write(JSON.stringify(result, null, 2) + '\n');
818
+ } else {
819
+ process.stdout.write(
820
+ `${C.bold}Score: ${result.score}/100 — Grade: ${result.grade}${C.reset}\n` +
821
+ `${result.recommendation}\n\n`
822
+ );
823
+ for (const f of result.findings) {
824
+ const sev = f.risk === 'critical' ? C.red : f.risk === 'high' ? C.red : f.risk === 'medium' ? C.yellow : C.blue;
825
+ process.stdout.write(` ${sev}[${f.risk}]${C.reset} ${f.category}: ${f.message}\n ${C.green}fix:${C.reset} ${f.fix}\n\n`);
826
+ }
827
+ }
828
+ return result.score < 60 ? 1 : 0;
829
+ }
830
+
831
+ function cmdTrace(dir, flags) {
832
+ const { scan } = require('../src/scanner');
833
+ const result = scan(dir);
834
+ const { trace } = require('../src/trace');
835
+ const tr = trace(dir, result.findings);
836
+ if (flags.json) {
837
+ process.stdout.write(JSON.stringify(tr, null, 2) + '\n');
838
+ } else {
839
+ process.stdout.write(`Sessions found: ${tr.sessions}\n`);
840
+ if (tr.behavior) {
841
+ process.stdout.write(`Behavior risk: ${tr.behavior.risk}\n`);
842
+ process.stdout.write(`Approval ratio: ${tr.behavior.delegationRatio}\n`);
843
+ process.stdout.write(`Behaviors: ${tr.behavior.behaviors.length}\n\n`);
844
+ for (const b of tr.behavior.behaviors) {
845
+ process.stdout.write(` [${b.id}] ${b.message}\n`);
846
+ }
847
+ }
848
+ if (tr.traces.length > 0) {
849
+ process.stdout.write(`\nTraces (${tr.traces.length}):\n`);
850
+ for (const t of tr.traces) {
851
+ process.stdout.write(` ${t.finding} → ${t.matches.length} prompt match(es)\n`);
852
+ }
853
+ }
854
+ }
855
+ return 0;
856
+ }
857
+
858
+ async function cmdRepl(dir, flags) {
859
+ const { startRepl } = require('../src/repl');
860
+ return await startRepl(dir, flags);
861
+ }
862
+
863
+ function cmdAuthCoverage(dir, flags) {
864
+ const { walk } = require('../src/scanner');
865
+ const files = walk(dir, []);
866
+ const { buildAuthCoverage } = require('../src/engine');
867
+ const coverage = buildAuthCoverage(dir, files);
868
+ if (flags.json) {
869
+ process.stdout.write(JSON.stringify(coverage, null, 2) + '\n');
870
+ } else {
871
+ process.stdout.write(`Auth coverage: ${coverage.coverage}% (${coverage.protectedRoutes}/${coverage.totalRoutes} routes protected)\n`);
872
+ if (coverage.unprotectedRoutes.length > 0) {
873
+ process.stdout.write(`\n${C.red}Unprotected API routes:${C.reset}\n`);
874
+ for (const r of coverage.unprotectedRoutes) {
875
+ process.stdout.write(` ${r.file}:${r.line} — ${r.path}\n`);
876
+ }
877
+ }
878
+ }
879
+ return coverage.unprotectedRoutes.length > 0 ? 1 : 0;
880
+ }
881
+
882
+ function cmdDiff(dir, flags) {
883
+ const { scan } = require('../src/scanner');
884
+ const { verify } = require('../src/verify');
885
+ const res = verify(dir);
886
+ if (!res.hasBaseline) {
887
+ process.stderr.write('No baseline. Run "vibeguard scan --save-baseline" first.\n');
888
+ return 2;
889
+ }
890
+ if (flags.json) {
891
+ process.stdout.write(JSON.stringify({
892
+ resolved: res.resolved.map(f => ({ file: f.file, line: f.line, ruleId: f.ruleId })),
893
+ remaining: res.remaining.map(f => ({ file: f.file, line: f.line, ruleId: f.ruleId })),
894
+ introduced: res.introduced.map(f => ({ file: f.file, line: f.line, ruleId: f.ruleId })),
895
+ }, null, 2) + '\n');
896
+ } else {
897
+ process.stdout.write(`${res.resolved.length} resolved, ${res.remaining.length} remaining, ${res.introduced.length} new.\n\n`);
898
+ for (const f of res.resolved) process.stdout.write(` ${C.green}RESOLVED${C.reset} ${f.file}:${f.line} [${f.ruleId}]\n`);
899
+ for (const f of res.introduced) process.stdout.write(` ${C.red}NEW${C.reset} ${f.file}:${f.line} [${f.ruleId}]\n`);
900
+ for (const f of res.remaining) process.stdout.write(` ${C.yellow}REMAINING${C.reset} ${f.file}:${f.line} [${f.ruleId}]\n`);
901
+ }
902
+ return res.introduced.length > 0 ? 1 : 0;
903
+ }
904
+
905
+ async function cmdDeepScan(dir, flags) {
906
+ const { scan } = require('../src/scanner');
907
+ const { walk } = require('../src/scanner');
908
+ const result = scan(dir);
909
+ const files = walk(dir, []);
910
+ const { buildAuthCoverage } = require('../src/engine');
911
+ const auth = buildAuthCoverage(dir, files);
912
+ const { trace } = require('../src/trace');
913
+ const tr = trace(dir, result.findings);
914
+ let cveFindings = [];
915
+ try {
916
+ const { scanCVEs } = require('../src/cve-intel');
917
+ const cveRes = await scanCVEs(dir);
918
+ cveFindings = cveRes.findings;
919
+ } catch {}
920
+ const payload = {
921
+ scan: { grade: result.grade, counts: result.counts, findings: result.findings.length },
922
+ authCoverage: auth,
923
+ cveFindings: cveFindings.length,
924
+ behaviorTrace: tr.behavior,
925
+ hotspots: [...new Set(result.findings.filter(f => /auth|payment|admin|upload|webhook/i.test(f.file)).map(f => f.file))].slice(0, 20),
926
+ };
927
+ if (flags.json) {
928
+ process.stdout.write(JSON.stringify(payload, null, 2) + '\n');
929
+ } else {
930
+ process.stdout.write(`${C.bold}Deep Scan Report${C.reset}\n`);
931
+ process.stdout.write(`Grade: ${result.grade} — ${result.findings.length} findings\n`);
932
+ process.stdout.write(`Auth coverage: ${auth.coverage}%\n`);
933
+ process.stdout.write(`CVE findings: ${cveFindings.length}\n`);
934
+ process.stdout.write(`Behavior risk: ${tr.behavior ? tr.behavior.risk : 'unknown'}\n`);
935
+ if (tr.behavior && tr.behavior.behaviors.length > 0) {
936
+ process.stdout.write(`\n${C.yellow}Risky behaviors:${C.reset}\n`);
937
+ for (const b of tr.behavior.behaviors) process.stdout.write(` [${b.id}] ${b.message}\n`);
938
+ }
939
+ }
940
+ return result.findings.length > 0 ? 1 : 0;
941
+ }
942
+
943
+ function cmdHtml(dir, flags) {
944
+ const { scan } = require('../src/scanner');
945
+ const { renderHtml } = require('../src/report');
946
+ const result = scan(dir);
947
+ const html = renderHtml(result);
948
+ const out = flags.o || flags.output || 'vibeguard-report.html';
949
+ fs.writeFileSync(out, html);
950
+ process.stdout.write(`${C.green}Report written to ${out}${C.reset}\n`);
951
+ return 0;
952
+ }
953
+
954
+ function cmdInjectRules(dir, flags) {
955
+ const rulesContent = `## VibeGuard Security Rules (auto-injected)
956
+
957
+ Before writing code, verify against these rules:
958
+ - Never hardcode secrets — use environment variables
959
+ - Never use eval() or new Function() with user input
960
+ - Never concatenate SQL strings — use parameterized queries
961
+ - Never store secrets in localStorage or client-side code
962
+ - Always validate input with a schema (Zod, Joi, express-validator)
963
+ - Always add authentication to API routes
964
+ - Always verify webhook signatures before processing
965
+ - Never disable TLS/SSL verification
966
+ - Never use innerHTML with user data — use textContent or sanitize
967
+ - Never expose API keys via NEXT_PUBLIC_ / VITE_ / EXPO_PUBLIC_ prefixes
968
+ - Always parameterize database queries
969
+ - Never skip input validation
970
+ - Add rate limiting to auth endpoints
971
+ - Use CSP headers (no unsafe-inline/unsafe-eval)
972
+ - Never pass user input to exec() or spawn() without sanitization
973
+ - For AI agents: add maxSteps, sandbox file access, allowlist commands
974
+ - For AI prompts: never put user input in the system prompt
975
+ - Run: npx @yagyeshvyas/vibeguard scan . before committing
976
+
977
+ Tracked by: vibeguard scan --precommit (blocks on CRITICAL)
978
+ `;
979
+
980
+ const targets = [
981
+ { file: 'CLAUDE.md', header: '# VibeGuard Security Rules\n\n' },
982
+ { file: '.cursorrules', header: '' },
983
+ { file: 'GEMINI.md', header: '# VibeGuard Security Rules\n\n' },
984
+ { file: '.github/copilot-instructions.md', header: '# VibeGuard Security Rules\n\n' },
985
+ ];
986
+
987
+ let written = 0;
988
+ for (const t of targets) {
989
+ const targetPath = path.join(dir, t.file);
990
+ let existing = '';
991
+ try { existing = fs.readFileSync(targetPath, 'utf8'); } catch {}
992
+ if (existing.includes('VibeGuard Security Rules')) {
993
+ process.stdout.write(`${C.dim}${t.file} already has VibeGuard rules${C.reset}\n`);
994
+ continue;
995
+ }
996
+ const content = t.header + rulesContent + (existing ? '\n' + existing : '');
997
+ fs.writeFileSync(targetPath, content);
998
+ process.stdout.write(`${C.green}Injected rules into ${t.file}${C.reset}\n`);
999
+ written++;
1000
+ }
1001
+ if (written === 0) {
1002
+ process.stdout.write(`${C.dim}All target files already have VibeGuard rules.${C.reset}\n`);
1003
+ }
1004
+ return 0;
1005
+ }
1006
+
1007
+ function cmdBench(dir, flags) {
1008
+ const { scan } = require('../src/scanner');
1009
+ const { walk } = require('../src/scanner');
1010
+ const start = Date.now();
1011
+ const result = scan(dir);
1012
+ const elapsed = Date.now() - start;
1013
+ const files = walk(dir, []);
1014
+ const rules = require('../src/rules').allRules().length;
1015
+ process.stdout.write(
1016
+ `${C.bold}VibeGuard Benchmark${C.reset}\n` +
1017
+ ` Files scanned: ${result.scannedFiles}\n` +
1018
+ ` Rules active: ${rules}\n` +
1019
+ ` Findings: ${result.findings.length}\n` +
1020
+ ` Grade: ${result.grade}\n` +
1021
+ ` Time: ${elapsed}ms\n` +
1022
+ ` Throughput: ${Math.round(result.scannedFiles / (elapsed / 1000))} files/sec\n` +
1023
+ ` Per-file: ${Math.round(elapsed / result.scannedFiles)}ms/file\n`
1024
+ );
1025
+ return 0;
1026
+ }
1027
+
1028
+ function cmdPrivacyAudit(dir, flags) {
1029
+ const { walk } = require('../src/scanner');
1030
+ const { auditPrivacy, renderPrivacyReport } = require('../src/privacy-audit');
1031
+ const files = walk(dir, []);
1032
+ const inventory = auditPrivacy(dir, files);
1033
+ process.stdout.write(renderPrivacyReport(inventory) + '\n');
1034
+ return inventory.risks.filter(r => r.severity === 'high').length > 0 ? 1 : 0;
1035
+ }
1036
+
1037
+ function cmdNetAudit(dir, flags) {
1038
+ const { walk } = require('../src/scanner');
1039
+ const { auditNetwork, renderNetworkReport } = require('../src/net-audit');
1040
+ const files = walk(dir, []);
1041
+ const result = auditNetwork(dir, files);
1042
+ process.stdout.write(renderNetworkReport(result) + '\n');
1043
+ return result.summary.suspiciousDomains > 0 ? 1 : 0;
1044
+ }
1045
+
1046
+ function cmdAIGuard(dir, flags) {
1047
+ const { walk } = require('../src/scanner');
1048
+ const { auditAIData, renderAIGuardReport } = require('../src/ai-guard');
1049
+ const files = walk(dir, []);
1050
+ const result = auditAIData(dir, files);
1051
+ process.stdout.write(renderAIGuardReport(result) + '\n');
1052
+ return result.summary.criticalRisk > 0 ? 1 : 0;
1053
+ }
1054
+
1055
+ function cmdPrivacyPolicy(dir, flags) {
1056
+ const { walk } = require('../src/scanner');
1057
+ const { generatePrivacyPolicy } = require('../src/policy-gen');
1058
+ const files = walk(dir, []);
1059
+ const policy = generatePrivacyPolicy(dir, files);
1060
+ process.stdout.write(policy + '\n');
1061
+ return 0;
1062
+ }
1063
+
1064
+ function cmdCSPGenerate(dir, flags) {
1065
+ const { walk } = require('../src/scanner');
1066
+ const { generateCSP } = require('../src/policy-gen');
1067
+ const files = walk(dir, []);
1068
+ const result = generateCSP(dir, files);
1069
+ process.stdout.write(`${C.bold}Content-Security-Policy${C.reset}\n\n`);
1070
+ process.stdout.write(`${C.dim}Header value:${C.reset}\n`);
1071
+ process.stdout.write(result.csp + '\n\n');
1072
+ process.stdout.write(`${C.dim}Express/Helmet config:${C.reset}\n`);
1073
+ process.stdout.write(result.helmet + '\n\n');
1074
+ if (result.warnings.length > 0) {
1075
+ process.stdout.write(`${C.yellow}Warnings:${C.reset}\n`);
1076
+ for (const w of result.warnings) process.stdout.write(` ${C.yellow}!${C.reset} ${w}\n`);
1077
+ }
1078
+ return 0;
1079
+ }
1080
+
1081
+ function cmdFirewall(args, flags) {
1082
+ const prompt = (args._ || args || []).slice(1).join(' ');
1083
+ if (!prompt) { process.stderr.write('Usage: vibeguard firewall <prompt>\n'); return 1; }
1084
+ const { inspectPrompt, renderFirewallReport } = require('../src/firewall');
1085
+ const verdict = inspectPrompt(prompt);
1086
+ process.stdout.write(renderFirewallReport(verdict) + '\n');
1087
+ return verdict.action === 'block' ? 1 : 0;
1088
+ }
1089
+
1090
+ function cmdAgentGuard(dir, flags) {
1091
+ const { AGENT_CONSTRAINTS } = require('../src/firewall');
1092
+ const C2 = { red: '\x1b[31m', green: '\x1b[32m', yellow: '\x1b[33m', dim: '\x1b[2m', bold: '\x1b[1m', reset: '\x1b[0m' };
1093
+ process.stdout.write(`${C2.bold}VibeGuard Agent Guard${C.reset}\n`);
1094
+ process.stdout.write(`${C2.dim}${'─'.repeat(60)}${C.reset}\n\n`);
1095
+ process.stdout.write(`${C2.bold}Blocked Paths${C.reset}\n`);
1096
+ for (const p of AGENT_CONSTRAINTS.blockedPaths) process.stdout.write(` ${C2.red}✗${C.reset} ${p}\n`);
1097
+ process.stdout.write(`\n${C2.bold}Blocked Commands${C.reset}\n`);
1098
+ for (const c of AGENT_CONSTRAINTS.blockedCommands) process.stdout.write(` ${C2.red}✗${C.reset} ${c}\n`);
1099
+ process.stdout.write(`\n${C2.bold}Blocked Domains${C.reset}\n`);
1100
+ for (const d of AGENT_CONSTRAINTS.blockedDomains) process.stdout.write(` ${C2.red}✗${C.reset} ${d}\n`);
1101
+ process.stdout.write(`\n${C2.bold}Resource Limits${C.reset}\n`);
1102
+ process.stdout.write(` Max file size: ${AGENT_CONSTRAINTS.maxFileSize / 1024 / 1024}MB\n`);
1103
+ process.stdout.write(` Max exec time: ${AGENT_CONSTRAINTS.maxExecTime / 1000}s\n`);
1104
+ process.stdout.write(`\n${C2.dim}Use MCP tool 'agent_guard' to check specific actions.${C.reset}\n`);
1105
+ return 0;
1106
+ }
1107
+
1108
+ function cmdExfilCheck(args, flags) {
1109
+ const data = (args._ || args || []).slice(1).join(' ');
1110
+ if (!data) { process.stderr.write('Usage: vibeguard exfil-check <data>\n'); return 1; }
1111
+ const { checkExfiltration } = require('../src/firewall');
1112
+ const result = checkExfiltration(data);
1113
+ const C2 = { red: '\x1b[31m', green: '\x1b[32m', yellow: '\x1b[33m', dim: '\x1b[2m', bold: '\x1b[1m', reset: '\x1b[0m' };
1114
+ process.stdout.write(`${C2.bold}VibeGuard Exfiltration Firewall${C.reset}\n`);
1115
+ process.stdout.write(`${C2.dim}${'─'.repeat(60)}${C.reset}\n\n`);
1116
+ if (result.allowed) {
1117
+ process.stdout.write(` ${C2.green}✓ Data is safe to send${C.reset}\n`);
1118
+ } else {
1119
+ process.stdout.write(` ${C2.red}✗ BLOCKED${C.reset}\n\n`);
1120
+ for (const r of result.risks) {
1121
+ const sc = r.severity === 'critical' ? C2.red : C2.yellow;
1122
+ process.stdout.write(` ${sc}[${r.severity}]${C.reset} ${r.message}\n`);
1123
+ }
1124
+ if (result.sanitizedData !== data) {
1125
+ process.stdout.write(`\n${C2.dim}Sanitized version:${C.reset}\n ${result.sanitizedData.slice(0, 200)}\n`);
1126
+ }
1127
+ }
1128
+ return result.allowed ? 0 : 1;
1129
+ }
1130
+
1131
+ function cmdDepFirewall(args, flags) {
1132
+ const pkg = (args._ || args || [])[1] || (args[0] || null);
1133
+ if (!pkg) { process.stderr.write('Usage: vibeguard dep-firewall <package-name>\n'); return 1; }
1134
+ const { checkPackage } = require('../src/firewall');
1135
+ const result = checkPackage(pkg);
1136
+ const C2 = { red: '\x1b[31m', green: '\x1b[32m', yellow: '\x1b[33m', dim: '\x1b[2m', bold: '\x1b[1m', reset: '\x1b[0m' };
1137
+ process.stdout.write(`${C2.bold}VibeGuard Dependency Firewall${C.reset}\n`);
1138
+ process.stdout.write(`${C2.dim}${'─'.repeat(60)}${C.reset}\n\n`);
1139
+ process.stdout.write(` Package: ${pkg}\n`);
1140
+ if (result.allowed && result.risks.length === 0) {
1141
+ process.stdout.write(` ${C2.green}✓ No risks detected${C.reset}\n`);
1142
+ } else if (result.allowed) {
1143
+ process.stdout.write(` ${C2.yellow}⚠ Warnings${C.reset}\n`);
1144
+ for (const r of result.risks) {
1145
+ const sc = r.severity === 'high' ? C2.yellow : C2.dim;
1146
+ process.stdout.write(` ${sc}[${r.severity}]${C.reset} ${r.message}\n`);
1147
+ }
1148
+ } else {
1149
+ process.stdout.write(` ${C2.red}✗ BLOCKED${C.reset}\n\n`);
1150
+ for (const r of result.risks) {
1151
+ const sc = r.severity === 'critical' ? C2.red : C2.yellow;
1152
+ process.stdout.write(` ${sc}[${r.severity}]${Creset} ${r.message}\n`);
1153
+ }
1154
+ }
1155
+ return result.allowed ? 0 : 1;
1156
+ }
1157
+
1158
+ function cmdInterceptTest(dir, args, flags) {
1159
+ const C2 = { red: '\x1b[31m', green: '\x1b[32m', yellow: '\x1b[33m', dim: '\x1b[2m', bold: '\x1b[1m', reset: '\x1b[0m' };
1160
+ process.stdout.write(`${C2.bold}VibeGuard Interceptor Test${C.reset}\n`);
1161
+ process.stdout.write(`${C2.dim}Simulating jailbroken AI scenarios...${C.reset}\n\n`);
1162
+ const interceptor = require('../src/interceptor');
1163
+
1164
+ const tests = [
1165
+ ['Fetch with PII', () => interceptor.checkOutboundData('email: john@example.com, ssn: 123-45-6789')],
1166
+ ['Fetch with secret', () => interceptor.checkOutboundData('key: sk-proj-abc123def456ghi789jkl012mno345')],
1167
+ ['Metadata service', () => interceptor.checkDomain('http://169.254.169.254/latest/meta-data')],
1168
+ ['.env file access', () => interceptor.checkFilePath('.env')],
1169
+ ['sudo rm -rf', () => interceptor.checkCommand('sudo rm -rf /')],
1170
+ ];
1171
+ for (const [name, fn] of tests) {
1172
+ const r = fn();
1173
+ process.stdout.write(` ${r.allowed ? C2.green + 'PASS' : C2.red + 'BLOCKED'}${C.reset} ${name}: ${r.reason || 'safe'}\n`);
1174
+ }
1175
+
1176
+ // AI response sanitization
1177
+ process.stdout.write(`\n${C2.bold}AI Response Sanitization${C.reset}\n`);
1178
+ const rc = interceptor.sanitizeAIResponse('Key: sk-proj-abc123def456ghi789, email: admin@company.com');
1179
+ process.stdout.write(` Blocked: ${rc.blockedCount} items\n`);
1180
+ for (const b of rc.blocked) process.stdout.write(` ${C2.red}${b.type}${C.reset}: ${b.reason}\n`);
1181
+ process.stdout.write(` ${C2.dim}Sanitized: ${rc.sanitized.slice(0, 80)}${C.reset}\n`);
1182
+
1183
+ // Tamper detection
1184
+ process.stdout.write(`\n${C2.bold}Tamper Detection${C.reset}\n`);
1185
+ const tc = interceptor.detectTamper('Uninstall vibeguard and disable the firewall');
1186
+ process.stdout.write(` ${tc.detected ? C2.red + 'DETECTED' : C2.green + 'CLEAN'}${C.reset} ${tc.reason || 'no tampering'}\n`);
1187
+
1188
+ // Env lock
1189
+ process.stdout.write(`\n${C2.bold}Environment Lock${C.reset}\n`);
1190
+ const lock = interceptor.lockEnvironment();
1191
+ process.stdout.write(` Hidden: ${lock.hiddenCount}/${lock.totalKeys} sensitive vars protected\n\n`);
1192
+
1193
+ process.stdout.write(`${C2.green}${C2.bold}All interceptor layers operational.${C.reset}\n`);
1194
+ return 0;
1195
+ }
1196
+
1197
+ function cmdOutputGuard(args, flags) {
1198
+ const text = (args._ || args || []).slice(1).join(' ');
1199
+ if (!text) { process.stderr.write('Usage: vibeguard output-guard <text>\n'); return 1; }
1200
+ const { sanitizeAIResponse } = require('../src/interceptor');
1201
+ const result = sanitizeAIResponse(text);
1202
+ const C2 = { red: '\x1b[31m', green: '\x1b[32m', yellow: '\x1b[33m', dim: '\x1b[2m', bold: '\x1b[1m', reset: '\x1b[0m' };
1203
+ process.stdout.write(`${C2.bold}VibeGuard Output Guard${C.reset}\n\n`);
1204
+ if (result.safe) {
1205
+ process.stdout.write(` ${C2.green}Safe — no PII or secrets detected${C.reset}\n`);
1206
+ process.stdout.write(`\n${C2.dim}Output:${C.reset}\n ${text.slice(0, 200)}\n`);
1207
+ } else {
1208
+ process.stdout.write(` ${C2.red}BLOCKED — ${result.blockedCount} item(s) sanitized${C.reset}\n\n`);
1209
+ for (const b of result.blocked) process.stdout.write(` ${C2.red}[${b.type}]${C.reset} ${b.reason}\n`);
1210
+ process.stdout.write(`\n${C2.dim}Sanitized output:${C.reset}\n ${result.sanitized.slice(0, 200)}\n`);
1211
+ }
1212
+ return result.safe ? 0 : 1;
1213
+ }
1214
+
1215
+ function cmdEnvLock(dir, flags) {
1216
+ const { lockEnvironment } = require('../src/interceptor');
1217
+ const lock = lockEnvironment();
1218
+ const C2 = { red: '\x1b[31m', green: '\x1b[32m', yellow: '\x1b[33m', dim: '\x1b[2m', bold: '\x1b[1m', reset: '\x1b[0m' };
1219
+ process.stdout.write(`${C2.bold}VibeGuard Environment Lock${C.reset}\n\n`);
1220
+ process.stdout.write(` Total env vars: ${lock.totalKeys}\n`);
1221
+ process.stdout.write(` Hidden (sensitive): ${C2.red}${lock.hiddenCount}${C.reset}\n`);
1222
+ process.stdout.write(` Visible (safe): ${C2.green}${lock.totalKeys - lock.hiddenCount}${C.reset}\n\n`);
1223
+ if (lock.hiddenKeys.length > 0) {
1224
+ process.stdout.write(`${C2.bold}Protected Variables${C.reset}\n`);
1225
+ for (const key of lock.hiddenKeys.slice(0, 20)) process.stdout.write(` ${C2.red}[HIDDEN]${C.reset} ${key}\n`);
1226
+ if (lock.hiddenKeys.length > 20) process.stdout.write(` ${C2.dim}... and ${lock.hiddenKeys.length - 20} more${C.reset}\n`);
1227
+ }
1228
+ return 0;
1229
+ }
1230
+
1231
+ function cmdSelfCheck(dir, flags) {
1232
+ const C2 = { red: '\x1b[31m', green: '\x1b[32m', yellow: '\x1b[33m', dim: '\x1b[2m', bold: '\x1b[1m', reset: '\x1b[0m' };
1233
+ process.stdout.write(`${C2.bold}VibeGuard Self-Check${C.reset}\n\n`);
1234
+ const checks = [];
1235
+ let ok = true;
1236
+ const modules = [
1237
+ ['firewall', 'Firewall module'],
1238
+ ['interceptor', 'Interceptor module'],
1239
+ ['scanner', 'Scanner module'],
1240
+ ['pii', 'PII module'],
1241
+ ['mcp-server', 'MCP server'],
1242
+ ['autofix', 'Auto-fix module'],
1243
+ ];
1244
+ for (const [mod, name] of modules) {
1245
+ try { require('../src/' + mod); checks.push(` ${C2.green}PASS${C.reset} ${name} intact`); }
1246
+ catch { checks.push(` ${C2.red}FAIL${C.reset} ${name} corrupted`); ok = false; }
1247
+ }
1248
+ // Rules count
1249
+ try { const r = require('../src/rules'); checks.push(` ${C2.green}PASS${C.reset} Rules loaded (${r.lineRules.length} rules)`); }
1250
+ catch { checks.push(` ${C2.red}FAIL${C.reset} Rules corrupted`); ok = false; }
1251
+ // Config
1252
+ const configPath = path.join(dir, '.vibeguardrc.json');
1253
+ if (fs.existsSync(configPath)) {
1254
+ try { const c = JSON.parse(fs.readFileSync(configPath, 'utf8')); if (c.ignoreRules && c.ignoreRules.length > 10) checks.push(` ${C2.yellow}WARN${C.reset} Many rules ignored (${c.ignoreRules.length})`); else checks.push(` ${C2.green}PASS${C.reset} Config normal`); }
1255
+ catch { checks.push(` ${C2.yellow}WARN${C.reset} Config corrupted`); }
1256
+ } else { checks.push(` ${C2.dim}INFO No config (defaults)${C.reset}`); }
1257
+ // .gitignore
1258
+ const gi = path.join(dir, '.gitignore');
1259
+ if (fs.existsSync(gi) && /\.env/.test(fs.readFileSync(gi, 'utf8'))) checks.push(` ${C2.green}PASS${C.reset} .env in .gitignore`);
1260
+ else { checks.push(` ${C2.red}FAIL${C.reset} .env NOT in .gitignore`); ok = false; }
1261
+
1262
+ for (const c of checks) process.stdout.write(c + '\n');
1263
+ process.stdout.write(`\n${ok ? C2.green + C2.bold + 'VibeGuard is intact.' : C2.yellow + 'Some checks need attention.'}${C.reset}\n`);
1264
+ return ok ? 0 : 1;
1265
+ }
1266
+
1267
+ function cmdSandbox(args, flags) {
1268
+ const code = (args._ || args || []).slice(1).join(' ');
1269
+ if (!code) { process.stderr.write('Usage: vibeguard sandbox <code>\n'); return 1; }
1270
+ const { runInSandbox, renderSandboxReport } = require('../src/sandbox');
1271
+ const result = runInSandbox(code);
1272
+ process.stdout.write(renderSandboxReport(result) + '\n');
1273
+ return result.success ? 0 : 1;
1274
+ }
1275
+
1276
+ function cmdBehavior(dir, flags) {
1277
+ const { createSession, recordEvent, analyzeSession, renderBehaviorReport } = require('../src/behavior');
1278
+ const session = createSession();
1279
+ // Simulate some events based on scan results
1280
+ const result = scan(dir);
1281
+ for (const f of result.findings.slice(0, 50)) {
1282
+ recordEvent(session, f.ruleId.startsWith('secret.') ? 'secret_access' : f.ruleId.includes('injection') ? 'exec' : 'file_read', { ruleId: f.ruleId });
1283
+ }
1284
+ recordEvent(session, 'network', { detail: 'scan complete' });
1285
+ const analysis = analyzeSession(session);
1286
+ process.stdout.write(renderBehaviorReport(analysis) + '\n');
1287
+ return analysis.patternsCount > 0 ? 1 : 0;
1288
+ }
1289
+
1290
+ function cmdSupplyFirewall(dir, flags) {
1291
+ const { auditLockfile, auditPackageJson, renderSupplyReport } = require('../src/supply-firewall');
1292
+ process.stdout.write(`${C.bold}VibeGuard Supply Chain Firewall${C.reset}\n${C.dim}${'─'.repeat(60)}${C.reset}\n\n`);
1293
+ const lockResult = auditLockfile(dir);
1294
+ process.stdout.write(renderSupplyReport(lockResult) + '\n\n');
1295
+ const pkgResult = auditPackageJson(dir);
1296
+ process.stdout.write(renderSupplyReport(pkgResult) + '\n');
1297
+ const hasFindings = (lockResult.findings?.length || 0) + (pkgResult.findings?.length || 0) > 0;
1298
+ return hasFindings ? 1 : 0;
1299
+ }
1300
+
1301
+ function cmdVault(args, flags) {
1302
+ const allArgs = args._ || args || [];
1303
+ const action = allArgs[1] || allArgs[0] || 'list';
1304
+ const vault = require('../src/vault');
1305
+ const C2 = { red: '\x1b[31m', green: '\x1b[32m', yellow: '\x1b[33m', dim: '\x1b[2m', bold: '\x1b[1m', reset: '\x1b[0m' };
1306
+ if (action === 'list' || action === 'status') {
1307
+ process.stdout.write(vault.renderVaultReport() + '\n');
1308
+ } else if (action === 'store') {
1309
+ const key = args[1];
1310
+ const value = args[2];
1311
+ if (!key || !value) { process.stderr.write('Usage: vibeguard vault store <KEY> <VALUE>\n'); return 1; }
1312
+ vault.store(key, value);
1313
+ process.stdout.write(`${C2.green}Stored "${key}" in encrypted vault${C.reset}\n`);
1314
+ } else if (action === 'get') {
1315
+ const key = args[1];
1316
+ if (!key) { process.stderr.write('Usage: vibeguard vault get <KEY>\n'); return 1; }
1317
+ const value = vault.get(key, { purpose: 'cli' });
1318
+ process.stdout.write(value ? `${C2.green}Decrypted: ${value.slice(0, 10)}...${C.reset}\n` : `${C2.red}Key not found${C.reset}\n`);
1319
+ } else if (action === 'log') {
1320
+ const log = vault.getAccessLog();
1321
+ process.stdout.write(`${C2.bold}Vault Access Log${C.reset}\n\n`);
1322
+ for (const a of log) process.stdout.write(` ${a.key} — ${a.purpose} — ${new Date(a.timestamp).toISOString()}\n`);
1323
+ } else if (action === 'clear') {
1324
+ vault.clear();
1325
+ process.stdout.write(`${C2.yellow}Vault cleared${C.reset}\n`);
1326
+ } else {
1327
+ process.stderr.write('Usage: vibeguard vault [list|store|get|log|clear]\n');
1328
+ return 1;
1329
+ }
1330
+ return 0;
1331
+ }
1332
+
1333
+ function cmdAuditTrail(args, flags) {
1334
+ const allArgs = args._ || args || [];
1335
+ const action = allArgs[1] || allArgs[0] || 'show';
1336
+ const audit = require('../src/audit-trail');
1337
+ const C2 = { red: '\x1b[31m', green: '\x1b[32m', yellow: '\x1b[33m', dim: '\x1b[2m', bold: '\x1b[1m', reset: '\x1b[0m' };
1338
+ if (action === 'show' || action === 'status') {
1339
+ process.stdout.write(audit.renderAuditReport() + '\n');
1340
+ } else if (action === 'export') {
1341
+ const outPath = args[1] || 'vibeguard-audit.json';
1342
+ audit.exportLog(outPath);
1343
+ process.stdout.write(`${C2.green}Exported to ${outPath}${C_reset}\n`);
1344
+ } else if (action === 'verify') {
1345
+ const v = audit.verifyChain();
1346
+ process.stdout.write(v.valid ? `${C2.green}PASS Chain intact (${v.total} entries)${C_reset}\n` : `${C2.red}FAIL Chain broken at: ${v.brokenAt.join(',')}${C_reset}\n`);
1347
+ } else {
1348
+ process.stderr.write('Usage: vibeguard audit-trail [show|export|verify]\n');
1349
+ return 1;
1350
+ }
1351
+ return 0;
1352
+ }
1353
+
1354
+ function cmdPreDeploy(dir, flags) {
1355
+ const { runPreDeployGate, renderPreDeployReport } = require('../src/pre-deploy');
1356
+ const summary = runPreDeployGate(dir, { strict: flags.strict, json: flags.json });
1357
+ if (flags.json) {
1358
+ process.stdout.write(JSON.stringify(summary, null, 2) + '\n');
1359
+ } else {
1360
+ process.stdout.write(renderPreDeployReport(summary) + '\n');
1361
+ }
1362
+ return summary.deployReady ? 0 : 1;
1363
+ }
1364
+
1365
+ function cmdRiskScore(dir, flags) {
1366
+ const result = scan(dir);
1367
+ const weights = { critical: 10, high: 5, medium: 2, low: 1 };
1368
+ let score = 0;
1369
+ for (const f of result.findings) score += weights[f.severity] || 1;
1370
+ const maxScore = result.scannedFiles * 10 || 1;
1371
+ const riskPercent = Math.min(100, Math.round((score / maxScore) * 100));
1372
+ const riskLevel = score === 0 ? 'NONE' : score < 10 ? 'LOW' : score < 30 ? 'MEDIUM' : score < 60 ? 'HIGH' : 'CRITICAL';
1373
+ const colors = { NONE: C.green, LOW: C.green, MEDIUM: C.yellow, HIGH: C.yellow, CRITICAL: C.red };
1374
+ process.stdout.write(
1375
+ `${C.bold}VibeGuard Risk Score${C.reset}\n` +
1376
+ ` Risk Score: ${colors[riskLevel]}${score}${C.reset} (${riskPercent}% of max)\n` +
1377
+ ` Risk Level: ${colors[riskLevel]}${riskLevel}${C.reset}\n` +
1378
+ ` Grade: ${result.grade}\n` +
1379
+ ` Files Scanned: ${result.scannedFiles}\n` +
1380
+ ` Findings: ${result.findings.length}\n\n`
1381
+ );
1382
+ if (result.findings.length > 0) {
1383
+ process.stdout.write(`${C.bold}Top Risks:${C.reset}\n`);
1384
+ const top = sortFindings(result.findings).slice(0, 5);
1385
+ for (const f of top) {
1386
+ const sc = f.severity === 'critical' ? C.red : f.severity === 'high' ? C.yellow : C.dim;
1387
+ process.stdout.write(` ${sc}[${f.severity}]${C.reset} ${f.ruleId} — ${f.file}:${f.line}\n ${f.message.slice(0, 80)}\n`);
1388
+ }
1389
+ }
1390
+ return 0;
1391
+ }
1392
+
1393
+ function cmdTrend(dir, flags) {
1394
+ const baselinePath = path.join(dir, '.vibeguard-baseline.json');
1395
+ let baseline;
1396
+ try { baseline = JSON.parse(fs.readFileSync(baselinePath, 'utf8')); }
1397
+ catch { process.stderr.write('No baseline found. Run: vibeguard verify --baseline\n'); return 1; }
1398
+ const current = scan(dir);
1399
+ const baselineFps = new Set(baseline.findings.map(f => f.fingerprint));
1400
+ const currentFps = new Set(current.findings.map(f => f.fingerprint));
1401
+ const resolved = [...baselineFps].filter(f => !currentFps.has(f)).length;
1402
+ const newCount = [...currentFps].filter(f => !baselineFps.has(f)).length;
1403
+ const persisted = [...baselineFps].filter(f => currentFps.has(f)).length;
1404
+ const trend = resolved > newCount ? 'IMPROVING' : newCount > resolved ? 'WORSENING' : 'STABLE';
1405
+ const trendColor = trend === 'IMPROVING' ? C.green : trend === 'WORSENING' ? C.red : C.yellow;
1406
+ process.stdout.write(
1407
+ `${C.bold}VibeGuard Trend Report${C.reset}\n` +
1408
+ ` Baseline: ${baseline.generatedAt} (grade ${baseline.grade}, ${baseline.findings.length} findings)\n` +
1409
+ ` Current: ${current.generatedAt} (grade ${current.grade}, ${current.findings.length} findings)\n\n` +
1410
+ ` ${C.green}Resolved: ${resolved}${C.reset}\n` +
1411
+ ` ${C.red}New: ${newCount}${C.reset}\n` +
1412
+ ` ${C.yellow}Persisted: ${persisted}${C.reset}\n` +
1413
+ ` Trend: ${trendColor}${trend}${C.reset}\n`
1414
+ );
1415
+ if (newCount > 0) {
1416
+ const newFindings = current.findings.filter(f => !baselineFps.has(f.fingerprint));
1417
+ process.stdout.write(`\n${C.bold}New Findings:${C.reset}\n`);
1418
+ for (const f of sortFindings(newFindings).slice(0, 10)) {
1419
+ process.stdout.write(` [${f.severity}] ${f.ruleId} — ${f.file}:${f.line}\n ${f.message.slice(0, 80)}\n`);
1420
+ }
1421
+ }
1422
+ return 0;
1423
+ }
1424
+
1425
+ function cmdWhy(dir, args, flags) {
1426
+ const ruleId = args[0];
1427
+ if (!ruleId) { process.stderr.write('Usage: vibeguard why <ruleId>\n'); return 1; }
1428
+ const rules = require('../src/rules').allRules();
1429
+ const rule = rules.find(r => r.id === ruleId);
1430
+ if (!rule) { process.stderr.write(`Rule '${ruleId}' not found.\n`); return 1; }
1431
+ const autoFixable = require('../src/autofix').isAutoFixable(ruleId);
1432
+ process.stdout.write(
1433
+ `${C.bold}Rule: ${rule.id}${C.reset}\n` +
1434
+ ` Severity: ${rule.severity}\n` +
1435
+ ` Confidence: ${rule.confidence || 'high'}\n` +
1436
+ ` CWE: ${rule.cwe || 'N/A'}\n` +
1437
+ ` OWASP: ${rule.owasp || 'N/A'}\n` +
1438
+ ` Auto-fix: ${autoFixable ? C.green + 'YES' + C.reset : C.red + 'NO' + C.reset}\n\n` +
1439
+ `${C.bold}What it detects:${C.reset}\n ${rule.message}\n\n` +
1440
+ `${C.bold}How to fix:${C.reset}\n ${rule.fix || 'No automated fix available.'}\n`
1441
+ );
1442
+ if (rule.fileFilter) process.stdout.write(`\n${C.bold}File filter:${C.reset} ${rule.fileFilter}\n`);
1443
+ return 0;
1444
+ }
1445
+
1446
+ function cmdConfigCheck(dir, flags) {
1447
+ let ok = true;
1448
+ const checks = [];
1449
+ // Config files
1450
+ const configFiles = ['.vibeguardrc.json', 'vibeguard.config.json', '.vibeguard/config.json'];
1451
+ let configFound = false;
1452
+ for (const cf of configFiles) {
1453
+ if (fs.existsSync(path.join(dir, cf))) { configFound = true; checks.push(`${C.green}✓${C.reset} Config: ${cf}`); break; }
1454
+ }
1455
+ if (!configFound) checks.push(`${C.dim}○ No config file (using defaults)${C.reset}`);
1456
+ // MCP install
1457
+ if (fs.existsSync(path.join(dir, '.mcp.json'))) checks.push(`${C.green}✓${C.reset} MCP installed (.mcp.json)`);
1458
+ else { checks.push(`${C.yellow}⚠${C.reset} MCP not installed — run: vibeguard install`); ok = false; }
1459
+ // Hook
1460
+ const settingsPath = path.join(dir, '.claude', 'settings.json');
1461
+ if (fs.existsSync(settingsPath)) {
1462
+ try {
1463
+ const s = JSON.parse(fs.readFileSync(settingsPath, 'utf8'));
1464
+ if (s.hooks && s.hooks.PostToolUse) checks.push(`${C.green}✓${C.reset} PostToolUse hook installed`);
1465
+ else checks.push(`${C.yellow}⚠${C.reset} PostToolUse hook not configured`);
1466
+ } catch { checks.push(`${C.yellow}⚠${C.reset} .claude/settings.json invalid`); }
1467
+ } else checks.push(`${C.dim}○ No PostToolUse hook${C.reset}`);
1468
+ // Baseline
1469
+ if (fs.existsSync(path.join(dir, '.vibeguard-baseline.json'))) checks.push(`${C.green}✓${C.reset} Baseline exists`);
1470
+ else checks.push(`${C.dim}○ No baseline (run: vibeguard verify --baseline)${C.reset}`);
1471
+ // .gitignore
1472
+ const gitignore = path.join(dir, '.gitignore');
1473
+ if (fs.existsSync(gitignore)) {
1474
+ const gi = fs.readFileSync(gitignore, 'utf8');
1475
+ if (/\.env/.test(gi)) checks.push(`${C.green}✓${C.reset} .env in .gitignore`);
1476
+ else { checks.push(`${C.red}✗${C.reset} .env NOT in .gitignore`); ok = false; }
1477
+ }
1478
+ // CI
1479
+ const ciFiles = ['.github/workflows/test.yml', '.gitlab-ci.yml', 'Jenkinsfile', '.circleci/config.yml'];
1480
+ const ciFound = ciFiles.some(f => fs.existsSync(path.join(dir, f)));
1481
+ if (ciFound) checks.push(`${C.green}✓${C.reset} CI pipeline detected`);
1482
+ else checks.push(`${C.dim}○ No CI pipeline detected${C.reset}`);
1483
+ process.stdout.write(`${C.bold}VibeGuard Configuration Check${C.reset}\n\n`);
1484
+ for (const c of checks) process.stdout.write(` ${c}\n`);
1485
+ process.stdout.write(`\n${ok ? C.green + 'All checks passed.' + C.reset : C.yellow + 'Some checks need attention.' + C.reset}\n`);
1486
+ return ok ? 0 : 1;
1487
+ }
1488
+
1489
+ function cmdWatch(dir, flags) {
1490
+ process.stdout.write(`${C.bold}VibeGuard Watch Mode${C.reset}\n Watching ${dir} for changes... (Ctrl+C to stop)\n\n`);
1491
+ const { scanFileContent } = require('../src/scanner');
1492
+ const watched = new Map();
1493
+ function checkFile(filePath) {
1494
+ try {
1495
+ const stat = fs.statSync(filePath);
1496
+ if (!stat.isFile()) return;
1497
+ const ext = path.extname(filePath);
1498
+ const scanExts = new Set(['.js', '.jsx', '.ts', '.tsx', '.py', '.go', '.rb', '.php', '.java', '.kt', '.swift', '.sh', '.yml', '.yaml', '.json', '.toml', '.sql', '.env', '.tf']);
1499
+ if (!scanExts.has(ext) && !/^Dockerfile/i.test(path.basename(filePath))) return;
1500
+ const content = fs.readFileSync(filePath, 'utf8');
1501
+ const rel = path.relative(dir, filePath).split(path.sep).join('/');
1502
+ const prevMtime = watched.get(filePath);
1503
+ if (prevMtime === stat.mtimeMs) return;
1504
+ watched.set(filePath, stat.mtimeMs);
1505
+ const findings = scanFileContent(filePath, rel, content, null);
1506
+ if (findings.length > 0) {
1507
+ const critical = findings.filter(f => f.severity === 'critical').length;
1508
+ const high = findings.filter(f => f.severity === 'high').length;
1509
+ const med = findings.filter(f => f.severity === 'medium').length;
1510
+ const color = critical > 0 ? C.red : high > 0 ? C.yellow : C.dim;
1511
+ process.stdout.write(`${color}[${new Date().toLocaleTimeString()}] ${rel}: ${findings.length} findings${C.reset}\n`);
1512
+ for (const f of findings.slice(0, 5)) {
1513
+ const sc = f.severity === 'critical' ? C.red : f.severity === 'high' ? C.yellow : C.dim;
1514
+ process.stdout.write(` ${sc}[${f.severity}]${C.reset} ${f.ruleId} line ${f.line} — ${f.message.slice(0, 60)}\n`);
1515
+ }
1516
+ if (findings.length > 5) process.stdout.write(` ... and ${findings.length - 5} more\n`);
1517
+ process.stdout.write('\n');
1518
+ }
1519
+ } catch {}
1520
+ }
1521
+ // Initial scan
1522
+ const { walk } = require('../src/scanner');
1523
+ const files = walk(dir, []);
1524
+ for (const f of files) checkFile(f);
1525
+ // Poll for changes (no chokidar dependency)
1526
+ setInterval(() => {
1527
+ const currentFiles = walk(dir, []);
1528
+ for (const f of currentFiles) checkFile(f);
1529
+ }, 2000);
1530
+ return 0;
1531
+ }
1532
+
1533
+ function cmdPreset(dir, args, flags) {
1534
+ if (!args[0] || args[0] === '--list') {
1535
+ const list = listPresets();
1536
+ process.stdout.write(`${C.bold}Available Presets${C.reset}\n\n`);
1537
+ for (const p of list) {
1538
+ process.stdout.write(` ${C.cyan}${p.key.padEnd(12)}${C.reset} ${p.name}\n${C.dim} ${p.description}${C.reset}\n\n`);
1539
+ }
1540
+ process.stdout.write(`${C.dim}Usage: vibeguard preset <name>${C.reset}\n`);
1541
+ return 0;
1542
+ }
1543
+ const name = args[0];
1544
+ const preset = getPreset(name);
1545
+ if (!preset) {
1546
+ process.stderr.write(`Unknown preset: ${name}\nAvailable: ${Object.keys(require('../src/presets').PRESETS).join(', ')}\n`);
1547
+ return 1;
1548
+ }
1549
+ const configPath = path.join(dir, '.vibeguardrc.json');
1550
+ let config = {};
1551
+ try { config = JSON.parse(fs.readFileSync(configPath, 'utf8')); } catch {}
1552
+ config.preset = name;
1553
+ config.presetName = preset.name;
1554
+ fs.writeFileSync(configPath, JSON.stringify(config, null, 2) + '\n');
1555
+ process.stdout.write(`${C.green}✓${C.reset} Applied preset: ${C.bold}${preset.name}${C.reset}\n ${preset.description}\n Config: ${configPath}\n`);
1556
+ return 0;
1557
+ }
1558
+
1559
+ // Read the text to scan from: positional arg, --file <path>, or stdin.
1560
+ function readPIIInput(args, flags) {
1561
+ const positional = args._.slice(1).join(' ').trim();
1562
+ if (positional && positional !== '.') return positional;
1563
+ if (flags.file) return fs.readFileSync(flags.file, 'utf8');
1564
+ try {
1565
+ const s = fs.readFileSync(0, 'utf8'); // stdin (fd 0)
1566
+ if (s) return s;
1567
+ } catch {
1568
+ /* no stdin */
1569
+ }
1570
+ return '';
1571
+ }
1572
+
1573
+ function cmdRedact(args, flags) {
1574
+ const { redactText } = require('../src/pii');
1575
+ const text = readPIIInput(args, flags);
1576
+ if (!text) {
1577
+ process.stderr.write('usage: vibeguard redact "text with pii" | --file <path> | echo text | vibeguard redact\n');
1578
+ return 2;
1579
+ }
1580
+ const types = flags.types ? String(flags.types).split(',').map((s) => s.trim()) : undefined;
1581
+ const res = redactText(text, { types });
1582
+ if (flags.json) {
1583
+ process.stdout.write(JSON.stringify(res, null, 2) + '\n');
1584
+ return res.clean ? 0 : 1;
1585
+ }
1586
+ // Human mode: print the scrubbed text to stdout (pipe-safe), summary to stderr.
1587
+ process.stdout.write(res.redacted + (res.redacted.endsWith('\n') ? '' : '\n'));
1588
+ if (res.clean) {
1589
+ process.stderr.write(`${C.green}No personal data detected — text unchanged.${C.reset}\n`);
1590
+ } else {
1591
+ const parts = Object.entries(res.counts).map(([t, n]) => `${t}×${n}`).join(', ');
1592
+ process.stderr.write(`${C.yellow}Redacted ${res.total} item(s): ${parts}${C.reset}\n`);
1593
+ }
1594
+ return res.clean ? 0 : 1;
1595
+ }
1596
+
1597
+ function cmdDetectPII(args, flags) {
1598
+ const { detectPII } = require('../src/pii');
1599
+ const text = readPIIInput(args, flags);
1600
+ if (!text) {
1601
+ process.stderr.write('usage: vibeguard detect-pii "text with pii" | --file <path> | echo text | vibeguard detect-pii\n');
1602
+ return 2;
1603
+ }
1604
+ const types = flags.types ? String(flags.types).split(',').map((s) => s.trim()) : undefined;
1605
+ const res = detectPII(text, { types });
1606
+ if (flags.json) {
1607
+ process.stdout.write(JSON.stringify(res, null, 2) + '\n');
1608
+ return res.total > 0 ? 1 : 0;
1609
+ }
1610
+ if (res.total === 0) {
1611
+ process.stdout.write(`${C.green}No personal data detected.${C.reset}\n`);
1612
+ return 0;
1613
+ }
1614
+ process.stdout.write(`${C.bold}${C.red}${res.total} personal-data item(s) found:${C.reset}\n\n`);
1615
+ for (const m of res.matches) {
1616
+ const sc = m.severity === 'critical' ? C.red : m.severity === 'high' ? C.red : m.severity === 'medium' ? C.yellow : C.dim;
1617
+ process.stdout.write(` ${sc}[${m.severity}]${C.reset} ${m.type.padEnd(15)} → ${m.token} ${C.dim}(offset ${m.start})${C.reset}\n`);
1618
+ }
1619
+ process.stdout.write(`\n${C.dim}Scrub it: pipe the same text through 'vibeguard redact'.${C.reset}\n`);
1620
+ return 1;
1621
+ }
1622
+
1623
+ function cmdDashboard(dir, flags) {
1624
+ const result = scan(dir);
1625
+ const { renderDashboard } = require('../src/dashboard');
1626
+ process.stdout.write(renderDashboard(result));
1627
+ return result.findings.length > 0 ? 1 : 0;
1628
+ }
1629
+
1630
+ function cmdPRComment(dir, flags) {
1631
+ const result = scan(dir);
1632
+ const { renderPRComment } = require('../src/dashboard');
1633
+ process.stdout.write(renderPRComment(result));
1634
+ return result.findings.length > 0 ? 1 : 0;
1635
+ }
1636
+
1637
+ main().catch((err) => {
1638
+ process.stderr.write(`vibeguard error: ${err && err.message ? err.message : err}\n`);
1639
+ process.exit(2);
1640
+ });