@darrenjcoxon/vibeoptimise 1.0.1 → 1.0.4

package/dist/scanners/css-efficiency.js

@@ -174,12 +174,23 @@ export class CssEfficiencyScanner {
     }
     extractSelectors(content) {
         const selectors = [];
+        // Keyframe stops are NOT selectors — filter them out
+        const keyframeStops = new Set(['from', 'to', '0%', '100%', '50%', '25%', '75%']);
         const matches = content.matchAll(/^([^@{}/\n][^{]*)\{/gm);
         for (const match of matches) {
             const sel = match[1].trim();
-            if (sel && !sel.startsWith('/*') && !sel.startsWith('//')) {
-                selectors.push(sel);
-            }
+            if (!sel)
+                continue;
+            if (sel.startsWith('/*') || sel.startsWith('//'))
+                continue;
+            // Skip keyframe percentage stops and named stops
+            if (keyframeStops.has(sel))
+                continue;
+            if (/^\d+%$/.test(sel))
+                continue; // Any percentage like 30%, 60%
+            if (/^\d+%\s*,\s*\d+%/.test(sel))
+                continue; // Combined like "0%, 100%"
+            selectors.push(sel);
         }
         return selectors;
     }

package/dist/scanners/depcheck.js

@@ -15,13 +15,7 @@ export class DepcheckScanner {
     description = 'Dependency analyzer — finds unused and missing npm packages';
     category = 'dead-code';
     async isAvailable() {
-        try {
-            execSync('npx --yes depcheck --version', { stdio: 'pipe', timeout: 30000 });
-            return true;
-        }
-        catch {
-            return false;
-        }
+        return true;
     }
     async scan(targetDir, options) {
         const start = Date.now();
@@ -78,19 +72,30 @@ export class DepcheckScanner {
                 'tailwindcss', 'postcss', 'autoprefixer',
                 'husky', 'lint-staged', 'commitlint',
                 '@playwright/test', 'vitest',
+                'dotenv', 'dotenv-cli', 'cross-env', // Used by scripts, not detectable
+                'prisma', '@prisma/client', // Used via generate/migrate, not direct imports
+                'supabase', // CLI tool, not a direct import
             ]);
             // Unused dependencies
             if (report.dependencies && Array.isArray(report.dependencies)) {
                 for (const dep of report.dependencies) {
+                    // In monorepos, "unused" deps may be consumed via workspace packages
+                    // that depcheck can't trace — lower severity and note this
+                    const severity = isMonorepo ? 'medium' : 'high';
+                    const monorepoNote = isMonorepo
+                        ? ' Note: in a monorepo, this package may be used by a workspace dependency that depcheck cannot trace.'
+                        : '';
                     findings.push({
                         id: `depcheck-unused-${dep}`,
                         scanner: this.name,
                         category: 'dead-code',
-                        severity: 'high',
+                        severity: severity,
                         title: `Unused dependency: ${dep}`,
-                        description: `Package "${dep}" is in dependencies but no usage was detected in the source code.`,
+                        description: `Package "${dep}" is in dependencies but no usage was detected in the source code.${monorepoNote}`,
                         file: 'package.json',
-                        suggestion: `Run \`npm uninstall ${dep}\` to remove it. This reduces install size and potential supply chain risk.`,
+                        suggestion: isMonorepo
+                            ? `Verify "${dep}" isn't used via workspace resolution before removing. Run \`grep -r "${dep}" --include="*.ts" --include="*.tsx" .\` to double-check.`
+                            : `Run \`npm uninstall ${dep}\` to remove it. This reduces install size and potential supply chain risk.`,
                         estimatedImpact: 'Faster installs, smaller node_modules, reduced attack surface',
                     });
                 }

package/dist/scanners/eslint-perf.js

@@ -18,13 +18,7 @@ export class EslintPerfScanner {
     description = 'Performance-focused linting — import cycles, unused imports, inefficient patterns';
     category = 'code-quality';
     async isAvailable() {
-        try {
-            execSync('npx --yes eslint --version', { stdio: 'pipe', timeout: 30000 });
-            return true;
-        }
-        catch {
-            return false;
-        }
+        return true;
     }
     async scan(targetDir, options) {
         const start = Date.now();

package/dist/scanners/jscpd.js

@@ -15,13 +15,7 @@ export class JscpdScanner {
     description = 'Copy/paste detector — finds duplicated code blocks across the codebase';
     category = 'duplication';
     async isAvailable() {
-        try {
-            execSync('npx --yes jscpd --version', { stdio: 'pipe', timeout: 30000 });
-            return true;
-        }
-        catch {
-            return false;
-        }
+        return true;
     }
     async scan(targetDir, options) {
         const start = Date.now();

package/dist/scanners/knip.js

@@ -15,13 +15,9 @@ export class KnipScanner {
     description = 'Dead code detector — unused files, exports, dependencies, types';
     category = 'dead-code';
     async isAvailable() {
-        try {
-            execSync('npx --yes knip --version', { stdio: 'pipe', timeout: 30000 });
-            return true;
-        }
-        catch {
-            return false;
-        }
+        // Always attempt to run — knip will be auto-installed via npx --yes during scan.
+        // Errors are handled gracefully in scan().
+        return true;
     }
     async scan(targetDir, options) {
         const start = Date.now();
@@ -38,6 +34,17 @@ export class KnipScanner {
             }
             let output;
             try {
+                // Ensure knip is available in the project context
+                // (knip needs typescript as a peer dep, resolved from project node_modules)
+                const hasTypescript = existsSync(join(targetDir, 'node_modules', 'typescript'));
+                if (!hasTypescript) {
+                    return {
+                        scanner: this.name,
+                        findings: [],
+                        summary: 'Skipped — typescript not installed in project (required by Knip)',
+                        duration: Date.now() - start,
+                    };
+                }
                 const excludeArgs = options.includeTests ? '' : '';
                 const cmd = `npx --yes knip --reporter json --no-exit-code ${excludeArgs}`;
                 output = execSync(cmd, {

package/dist/scanners/madge.js

@@ -15,13 +15,7 @@ export class MadgeScanner {
     description = 'Circular dependency detector — finds import cycles and orphaned modules';
     category = 'performance';
     async isAvailable() {
-        try {
-            execSync('npx --yes madge --version', { stdio: 'pipe', timeout: 30000 });
-            return true;
-        }
-        catch {
-            return false;
-        }
+        return true;
     }
     async scan(targetDir, options) {
         const start = Date.now();

package/dist/scanners/regex-safety.d.ts

@@ -25,18 +25,60 @@ export declare class RegexSafetyScanner implements Scanner {
     private extractRegexLiterals;
     private extractRegExpConstructors;
     /**
-     * Only flag genuinely dangerous patterns.
-     *
-     * We ONLY report:
-     * - Critical: Nested quantifiers (guaranteed exponential backtracking)
-     * - High: Overlapping alternation + quantifier (likely quadratic+)
-     * - Medium: 3+ greedy .* in same pattern (quadratic risk)
-     *
-     * We deliberately DO NOT flag:
-     * - Unanchored patterns (normal and expected)
-     * - Long regexes (complexity != vulnerability)
-     * - Single quantifiers (normal regex usage)
-     * - Two .* wildcards (common and usually fine)
+     * Only flag genuinely dangerous patterns — patterns where the regex engine
+     * can enter exponential or polynomial backtracking.
+     *
+     * KEY INSIGHT: A "nested quantifier" is only dangerous when the inner
+     * quantified expression can match the SAME characters as what follows.
+     *
+     * SAFE examples (we do NOT flag these):
+     * - ([^*\n]+?)[ \t]+   → [^*\n] is bounded, can't overlap with [ \t]
+     * - (\d+(?:\.\d+)?)    → \d is bounded, ? is not a loop quantifier
+     * - [\d+(?:\s*,\s*\d+)+] → requires , delimiter, can't backtrack
+     * - ([\s\S]*?)          → lazy quantifier with bounded context
+     *
+     * DANGEROUS examples (we DO flag these):
+     * - (a+)+              → unbounded a+ inside quantified group
+     * - (.*)*              → .* inside quantified group (classic ReDoS)
+     * - (\w+\s+)+          → \w+ and \s+ can alternate indefinitely
      */
     private analyzeRegex;
+    /**
+     * Check for genuinely dangerous nested quantifiers.
+     *
+     * Only flags when:
+     * 1. There's a group with a quantifier: (...)+  or (...)*  or (...){n,}
+     * 2. Inside that group, there's a quantified UNBOUNDED matcher
+     *    - . (dot), \w, \s, \d followed by + or *
+     *    - NOT [^specific]+ which is bounded by the exclusion
+     *    - NOT (?:...) non-capturing groups with ? (optional, not loop)
+     */
+    private hasDangerousNestedQuantifier;
+    /**
+     * Check if a group's content contains an inner quantifier that creates
+     * backtracking risk when the group itself is quantified.
+     *
+     * KEY RULE: (X+)+ is only dangerous when the regex engine can partition
+     * the input between inner/outer repetitions in many ways. A literal
+     * delimiter inside the group PREVENTS this because the engine has no
+     * ambiguity about where one repetition ends and the next begins.
+     *
+     * DANGEROUS: (a+)+, (.+)+, (\w+)+, (\s+\w+)+
+     * SAFE: (\s*,\s*\d+)+ — comma is a required literal delimiter
+     * SAFE: (\s+[A-Z][a-z]+)+ — [A-Z] after \s+ creates unambiguous boundary
+     * SAFE: ([^,]+,)+ — negated class + delimiter
+     * SAFE: (\d+(?:\.\d+)?) — ? is not a repeating quantifier
+     * SAFE: ([^*\n]+?)[ \t]+ — lazy quantifier + different char class
+     */
+    private hasUnboundedInnerQuantifier;
+    /**
+     * Check for overlapping alternation with quantifier.
+     * Only flags when alternation branches use unbounded matchers that
+     * can match the same characters.
+     *
+     * SAFE: (?:Mr|Mrs|Ms|Dr)\.? — fixed literals, no backtracking risk
+     * SAFE: (?:foo|bar)+ — fixed literals, no overlap
+     * DANGEROUS: (?:.*|.+)+ — unbounded matchers overlap
+     */
+    private hasDangerousAlternation;
 }

package/dist/scanners/regex-safety.js

@@ -186,57 +186,43 @@ export class RegexSafetyScanner {
         return regexes;
     }
     /**
-     * Only flag genuinely dangerous patterns.
+     * Only flag genuinely dangerous patterns — patterns where the regex engine
+     * can enter exponential or polynomial backtracking.
      *
-     * We ONLY report:
-     * - Critical: Nested quantifiers (guaranteed exponential backtracking)
-     * - High: Overlapping alternation + quantifier (likely quadratic+)
-     * - Medium: 3+ greedy .* in same pattern (quadratic risk)
+     * KEY INSIGHT: A "nested quantifier" is only dangerous when the inner
+     * quantified expression can match the SAME characters as what follows.
      *
-     * We deliberately DO NOT flag:
-     * - Unanchored patterns (normal and expected)
-     * - Long regexes (complexity != vulnerability)
-     * - Single quantifiers (normal regex usage)
-     * - Two .* wildcards (common and usually fine)
+     * SAFE examples (we do NOT flag these):
+     * - ([^*\n]+?)[ \t]+   → [^*\n] is bounded, can't overlap with [ \t]
+     * - (\d+(?:\.\d+)?)    → \d is bounded, ? is not a loop quantifier
+     * - [\d+(?:\s*,\s*\d+)+] → requires , delimiter, can't backtrack
+     * - ([\s\S]*?)          → lazy quantifier with bounded context
+     *
+     * DANGEROUS examples (we DO flag these):
+     * - (a+)+              → unbounded a+ inside quantified group
+     * - (.*)*              → .* inside quantified group (classic ReDoS)
+     * - (\w+\s+)+          → \w+ and \s+ can alternate indefinitely
      */
     analyzeRegex(pattern) {
         const issues = [];
-        // Critical: Nested quantifiers — (a+)+, (.*)*
-        if (/\([^)]*[+*][^)]*\)\s*[+*{]/.test(pattern) ||
-            /\([^)]*[+*][^)]*[+*][^)]*\)/.test(pattern)) {
+        // Critical: TRUE nested quantifiers only
+        // Pattern: (X+)+ or (X*)+ where X is an UNBOUNDED matcher (. or \w or \s)
+        // NOT: ([^specific]+)+ which is bounded and safe
+        if (this.hasDangerousNestedQuantifier(pattern)) {
             issues.push({
                 severity: 'critical',
                 description: 'Nested quantifiers — exponential backtracking risk (ReDoS)',
                 suggestion: 'Rewrite to avoid nested quantifiers. Instead of `(a+)+`, use `a+`. For complex patterns, consider the RE2 engine (npm re2) which guarantees linear time.',
             });
         }
-        // High: Overlapping alternation with quantifier — (a|ab)+
-        if (/\([^)]*\|[^)]*\)[+*{]/.test(pattern)) {
-            const groupMatch = pattern.match(/\(([^)]*)\)\s*[+*{]/);
-            if (groupMatch) {
-                const altParts = groupMatch[1].split('|');
-                if (altParts.length > 1) {
-                    const hasOverlap = altParts.some((a, i) => altParts.some((b, j) => {
-                        if (i === j)
-                            return false;
-                        // Both contain wildcards — definite overlap
-                        if ((a.includes('.') || a.includes('\\w') || a.includes('\\d')) &&
-                            (b.includes('.') || b.includes('\\w') || b.includes('\\d')))
-                            return true;
-                        // Same starting char — potential overlap
-                        const aFirst = a.replace(/^\\/, '')[0];
-                        const bFirst = b.replace(/^\\/, '')[0];
-                        return aFirst && bFirst && aFirst === bFirst;
-                    }));
-                    if (hasOverlap) {
-                        issues.push({
-                            severity: 'high',
-                            description: 'Overlapping alternation with quantifier — potential backtracking',
-                            suggestion: 'Ensure alternation branches are mutually exclusive, or rewrite to avoid the quantifier on the group.',
-                        });
-                    }
-                }
-            }
+        // High: Overlapping alternation with quantifier where branches can match same input
+        // Only flag when alternatives use unbounded matchers (., \w, \s)
+        if (this.hasDangerousAlternation(pattern)) {
+            issues.push({
+                severity: 'high',
+                description: 'Overlapping alternation with quantifier — potential backtracking',
+                suggestion: 'Ensure alternation branches are mutually exclusive, or rewrite to avoid the quantifier on the group.',
+            });
         }
         // Medium: 3+ greedy wildcards (2 is normal, 3+ is risky)
         const wildcardCount = (pattern.match(/\.\*/g) || []).length;
@@ -249,4 +235,113 @@ export class RegexSafetyScanner {
         }
         return issues;
     }
+    /**
+     * Check for genuinely dangerous nested quantifiers.
+     *
+     * Only flags when:
+     * 1. There's a group with a quantifier: (...)+  or (...)*  or (...){n,}
+     * 2. Inside that group, there's a quantified UNBOUNDED matcher
+     *    - . (dot), \w, \s, \d followed by + or *
+     *    - NOT [^specific]+ which is bounded by the exclusion
+     *    - NOT (?:...) non-capturing groups with ? (optional, not loop)
+     */
+    hasDangerousNestedQuantifier(pattern) {
+        // Match groups followed by quantifiers: (...)+ or (...)* or (...){2,}
+        const groupWithQuantifier = /\(([^)]+)\)[+*]|\(([^)]+)\)\{[\d,]+\}/g;
+        let match;
+        while ((match = groupWithQuantifier.exec(pattern)) !== null) {
+            const groupContent = match[1] || match[2];
+            if (!groupContent)
+                continue;
+            // Check if group contains an unbounded quantified expression
+            // Dangerous: .+, .*, \w+, \w*, \s+, \s*
+            // Safe: [^x]+, [specific]+, \d+ (bounded), lazy .*? in limited context
+            if (this.hasUnboundedInnerQuantifier(groupContent)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    /**
+     * Check if a group's content contains an inner quantifier that creates
+     * backtracking risk when the group itself is quantified.
+     *
+     * KEY RULE: (X+)+ is only dangerous when the regex engine can partition
+     * the input between inner/outer repetitions in many ways. A literal
+     * delimiter inside the group PREVENTS this because the engine has no
+     * ambiguity about where one repetition ends and the next begins.
+     *
+     * DANGEROUS: (a+)+, (.+)+, (\w+)+, (\s+\w+)+
+     * SAFE: (\s*,\s*\d+)+ — comma is a required literal delimiter
+     * SAFE: (\s+[A-Z][a-z]+)+ — [A-Z] after \s+ creates unambiguous boundary
+     * SAFE: ([^,]+,)+ — negated class + delimiter
+     * SAFE: (\d+(?:\.\d+)?) — ? is not a repeating quantifier
+     * SAFE: ([^*\n]+?)[ \t]+ — lazy quantifier + different char class
+     */
+    hasUnboundedInnerQuantifier(content) {
+        // Check for any atom followed by + or * (greedy) inside the group
+        const hasInnerQuantifier = /[^?][+*]/.test(content) || /^.[+*]/.test(content);
+        if (!hasInnerQuantifier)
+            return false;
+        // ── SAFE EXCEPTIONS ──
+        // Safe: Contains a required literal character (not a metachar) between quantified parts.
+        // e.g., \s*,\s*\d+ — the comma is required, preventing ambiguous partitioning.
+        // e.g., \s+[A-Z] — the [A-Z] after \s+ creates an unambiguous boundary.
+        // Look for: quantifier followed by a literal char or specific char class [A-Z], [a-z], etc.
+        if (/[+*]\s*[,;:=|&!@#'".\-\/]/.test(content)) {
+            // Has a required literal delimiter after a quantifier — safe
+            return false;
+        }
+        if (/[+*]\s*\[(?![\^])(?:[A-Z]|[a-z]|[0-9])/.test(content)) {
+            // Has a specific character class (not negated) after quantifier — safe
+            // e.g., \s+[A-Z] — the uppercase letter creates unambiguous boundary
+            return false;
+        }
+        // Safe: negated char class followed by a delimiter
+        // e.g., [^,]+, or [^"]+\" — the delimiter prevents overlap
+        if (/\[\^[^\]]+\][+*]/.test(content)) {
+            return false;
+        }
+        // Safe: lazy quantifier (+? or *?) — prevents catastrophic backtracking
+        if (/[+*]\?/.test(content) && !/[+*][^?].*[+*]/.test(content)) {
+            return false;
+        }
+        // Safe: \d+ is bounded (only digits, 0-9)
+        // Exception: (\d+\s*)+ IS dangerous because \s* can match empty
+        if (/\\d[+*]/.test(content) && !/\\[sw.][+*]/.test(content)) {
+            return false;
+        }
+        // Safe: only \s quantifiers with required non-\s between them
+        // e.g., \s*,\s* — the comma breaks the chain
+        if (/\\s[+*]/.test(content) && /\\s[+*][^\\+*]*[,;:=\-\/.]/.test(content)) {
+            return false;
+        }
+        return true;
+    }
+    /**
+     * Check for overlapping alternation with quantifier.
+     * Only flags when alternation branches use unbounded matchers that
+     * can match the same characters.
+     *
+     * SAFE: (?:Mr|Mrs|Ms|Dr)\.? — fixed literals, no backtracking risk
+     * SAFE: (?:foo|bar)+ — fixed literals, no overlap
+     * DANGEROUS: (?:.*|.+)+ — unbounded matchers overlap
+     */
+    hasDangerousAlternation(pattern) {
+        const match = pattern.match(/\(([^)]*\|[^)]*)\)\s*[+*{]/);
+        if (!match)
+            return false;
+        const altParts = match[1].split('|');
+        if (altParts.length < 2)
+            return false;
+        // Safe: All branches are fixed literals (no quantifiers inside)
+        // e.g., (Mr|Mrs|Ms|Dr) — these can't cause backtracking
+        const allLiteral = altParts.every(part => !/[+*{]/.test(part) && !/\\[wsd.]/.test(part));
+        if (allLiteral)
+            return false;
+        // Only flag if BOTH branches contain unbounded matchers
+        const hasUnbounded = (part) => /\.[+*]/.test(part) || /\\[ws][+*]/.test(part);
+        const unboundedCount = altParts.filter(hasUnbounded).length;
+        return unboundedCount >= 2;
+    }
 }

package/dist/scanners/source-map-explorer.js

@@ -15,13 +15,7 @@ export class SourceMapExplorerScanner {
     description = 'Bundle composition analyzer — shows what code is in your production bundles';
     category = 'bundle-size';
     async isAvailable() {
-        try {
-            execSync('npx --yes source-map-explorer --version', { stdio: 'pipe', timeout: 30000 });
-            return true;
-        }
-        catch {
-            return false;
-        }
+        return true;
     }
     async scan(targetDir, options) {
         const start = Date.now();

package/dist/utils/tool-installer.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Tool Installer Utility
+ *
+ * Robust availability checking for npm-based scanning tools.
+ * Tries local npx → npx --yes → global install as fallback.
+ */
+/**
+ * Check if an npm tool is available, installing it if needed.
+ *
+ * Strategy:
+ * 1. Try npx (uses local or cached version — fast)
+ * 2. Try npx --yes (auto-installs if not cached — slower)
+ * 3. Try global install as last resort
+ *
+ * @param packageName - npm package name (e.g., 'knip', 'jscpd', 'madge')
+ * @param versionFlag - flag to check version (default: '--version')
+ * @param cwd - optional working directory (needed for tools with peer deps)
+ * @returns true if tool is available
+ */
+export declare function isToolAvailable(packageName: string, versionFlag?: string, cwd?: string): boolean;
+/**
+ * Build a command that runs a tool via npx --yes.
+ * Ensures the tool will be auto-installed if not present.
+ */
+export declare function npxCmd(packageName: string, args: string): string;

package/dist/utils/tool-installer.js

@@ -0,0 +1,50 @@
+/**
+ * Tool Installer Utility
+ *
+ * Robust availability checking for npm-based scanning tools.
+ * Tries local npx → npx --yes → global install as fallback.
+ */
+import { execSync } from 'child_process';
+/**
+ * Check if an npm tool is available, installing it if needed.
+ *
+ * Strategy:
+ * 1. Try npx (uses local or cached version — fast)
+ * 2. Try npx --yes (auto-installs if not cached — slower)
+ * 3. Try global install as last resort
+ *
+ * @param packageName - npm package name (e.g., 'knip', 'jscpd', 'madge')
+ * @param versionFlag - flag to check version (default: '--version')
+ * @param cwd - optional working directory (needed for tools with peer deps)
+ * @returns true if tool is available
+ */
+export function isToolAvailable(packageName, versionFlag = '--version', cwd) {
+    const opts = { stdio: 'pipe', timeout: 15000, ...(cwd ? { cwd } : {}) };
+    const optsLong = { stdio: 'pipe', timeout: 90000, ...(cwd ? { cwd } : {}) };
+    // Try 1: Local/cached npx (fast path)
+    try {
+        execSync(`npx ${packageName} ${versionFlag}`, opts);
+        return true;
+    }
+    catch { }
+    // Try 2: npx --yes to auto-install (first-time download)
+    try {
+        execSync(`npx --yes ${packageName} ${versionFlag}`, optsLong);
+        return true;
+    }
+    catch { }
+    // Try 3: Global install as fallback
+    try {
+        execSync(`npm install -g ${packageName} 2>/dev/null && npx ${packageName} ${versionFlag}`, optsLong);
+        return true;
+    }
+    catch { }
+    return false;
+}
+/**
+ * Build a command that runs a tool via npx --yes.
+ * Ensures the tool will be auto-installed if not present.
+ */
+export function npxCmd(packageName, args) {
+    return `npx --yes ${packageName} ${args}`;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@darrenjcoxon/vibeoptimise",
-  "version": "1.0.1",
+  "version": "1.0.4",
   "description": "🚀 VibeOptimise — The ultimate codebase optimisation scanner. Find dead code, duplication, circular deps, bundle bloat & more. Get OPTIMISE.md for AI agents to fix everything.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",