driftdetect-core 0.6.1 → 0.7.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Geoffrey Fernald
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/constants/analysis/categorizer.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Constant Categorizer
+ *
+ * Infers the category of a constant based on its name, value, and context.
+ */
+import type { ConstantExtraction, ConstantCategory } from '../types.js';
+/**
+ * Infer the category of a constant
+ */
+export declare function inferCategory(constant: ConstantExtraction): ConstantCategory;
+/**
+ * Get category display name
+ */
+export declare function getCategoryDisplayName(category: ConstantCategory): string;
+/**
+ * Get category description
+ */
+export declare function getCategoryDescription(category: ConstantCategory): string;
+/**
+ * Check if a category is security-sensitive
+ */
+export declare function isSecuritySensitive(category: ConstantCategory): boolean;
+/**
+ * Suggest a better name for a constant based on its value
+ */
+export declare function suggestConstantName(value: string | number, category: ConstantCategory): string;
+//# sourceMappingURL=categorizer.d.ts.map

package/dist/constants/analysis/categorizer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"categorizer.d.ts","sourceRoot":"","sources":["../../../src/constants/analysis/categorizer.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,kBAAkB,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AA6NxE;;GAEG;AACH,wBAAgB,aAAa,CAAC,QAAQ,EAAE,kBAAkB,GAAG,gBAAgB,CA6C5E;AAED;;GAEG;AACH,wBAAgB,sBAAsB,CAAC,QAAQ,EAAE,gBAAgB,GAAG,MAAM,CAezE;AAED;;GAEG;AACH,wBAAgB,sBAAsB,CAAC,QAAQ,EAAE,gBAAgB,GAAG,MAAM,CAezE;AAED;;GAEG;AACH,wBAAgB,mBAAmB,CAAC,QAAQ,EAAE,gBAAgB,GAAG,OAAO,CAEvE;AAED;;GAEG;AACH,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,EAAE,QAAQ,EAAE,gBAAgB,GAAG,MAAM,CA6B9F"}

package/dist/constants/analysis/categorizer.js

@@ -0,0 +1,364 @@
+/**
+ * Constant Categorizer
+ *
+ * Infers the category of a constant based on its name, value, and context.
+ */
+/**
+ * Category inference patterns
+ */
+const CATEGORY_PATTERNS = {
+    config: {
+        namePatterns: [
+            /config/i,
+            /settings?/i,
+            /options?/i,
+            /defaults?/i,
+            /params?/i,
+            /preferences?/i,
+        ],
+        valuePatterns: [],
+        parentPatterns: [/config/i, /settings/i],
+    },
+    api: {
+        namePatterns: [
+            /^api/i,
+            /url$/i,
+            /endpoint/i,
+            /base_?url/i,
+            /host/i,
+            /port$/i,
+            /header/i,
+            /content.?type/i,
+            /accept/i,
+            /method/i,
+        ],
+        valuePatterns: [
+            /^https?:\/\//i,
+            /^\/api\//i,
+            /application\/json/i,
+            /text\/html/i,
+        ],
+        parentPatterns: [/api/i, /http/i, /client/i],
+    },
+    status: {
+        namePatterns: [
+            /status/i,
+            /state/i,
+            /phase/i,
+            /stage/i,
+            /step/i,
+            /mode/i,
+        ],
+        valuePatterns: [
+            /pending/i,
+            /active/i,
+            /completed/i,
+            /failed/i,
+            /success/i,
+            /error/i,
+            /cancelled/i,
+            /processing/i,
+        ],
+        parentPatterns: [/status/i, /state/i],
+    },
+    error: {
+        namePatterns: [
+            /^err_/i, // ERR_ prefix
+            /^error_/i, // ERROR_ prefix
+            /^e_/i, // E_ prefix
+            /_error$/i, // _ERROR suffix
+            /_err$/i, // _ERR suffix
+            /exception/i,
+            /^fault$/i, // Only match exact "fault", not "default"
+            /failure/i,
+        ],
+        valuePatterns: [
+            /error/i,
+            /failed/i,
+            /invalid/i,
+            /not.?found/i,
+            /unauthorized/i,
+            /forbidden/i,
+        ],
+        parentPatterns: [/error/i, /exception/i],
+    },
+    feature_flag: {
+        namePatterns: [
+            /feature/i,
+            /flag/i,
+            /^ff_/i,
+            /enable/i,
+            /disable/i,
+            /toggle/i,
+            /experiment/i,
+            /^is_/i,
+            /^has_/i,
+            /^can_/i,
+            /^should_/i,
+            /^use_/i,
+        ],
+        valuePatterns: [],
+        parentPatterns: [/feature/i, /flag/i],
+    },
+    limit: {
+        namePatterns: [
+            /^max_/i,
+            /^min_/i,
+            /_max$/i,
+            /_min$/i,
+            /^limit/i,
+            /_limit$/i,
+            /threshold/i,
+            /timeout/i,
+            /^size_/i,
+            /_size$/i,
+            /^count_/i,
+            /_count$/i,
+            /^length_/i,
+            /_length$/i,
+            /capacity/i,
+            /^rate_/i,
+            /_rate$/i,
+            /interval/i,
+            /delay/i,
+            /ttl/i,
+            /expire/i,
+            /duration/i,
+            /^retry_/i,
+            /_retry$/i,
+            /attempt/i,
+        ],
+        valuePatterns: [],
+        parentPatterns: [/limit/i, /config/i],
+    },
+    regex: {
+        namePatterns: [
+            /regex/i,
+            /regexp/i,
+            /pattern/i,
+            /^re_/i,
+        ],
+        valuePatterns: [
+            /^\/.+\/[gimsuvy]*$/,
+            /^\^.*\$$/,
+            /\[.*\]/,
+            /\(.*\)/,
+            /\\d|\\w|\\s/,
+        ],
+        parentPatterns: [/regex/i, /pattern/i, /validator/i],
+    },
+    path: {
+        namePatterns: [
+            /path/i,
+            /route/i,
+            /dir/i,
+            /directory/i,
+            /folder/i,
+            /file/i,
+            /location/i,
+        ],
+        valuePatterns: [
+            /^\/[a-z]/i,
+            /^\.\//,
+            /^\.\.\//,
+            /^[a-z]:\\/i,
+        ],
+        parentPatterns: [/path/i, /route/i],
+    },
+    env: {
+        namePatterns: [
+            /^env/i,
+            /environment/i,
+            /^node_env/i,
+            /^app_env/i,
+        ],
+        valuePatterns: [
+            /development/i,
+            /production/i,
+            /staging/i,
+            /test/i,
+            /local/i,
+        ],
+        parentPatterns: [/env/i, /environment/i],
+    },
+    security: {
+        namePatterns: [
+            /secret/i,
+            /password/i,
+            /passwd/i,
+            /credential/i,
+            /auth/i,
+            /token/i,
+            /key$/i,
+            /^api.?key/i,
+            /^private/i,
+            /^public.?key/i,
+            /certificate/i,
+            /cert$/i,
+            /salt/i,
+            /hash/i,
+            /encrypt/i,
+            /decrypt/i,
+        ],
+        valuePatterns: [
+            /^sk_/i,
+            /^pk_/i,
+            /^-----BEGIN/,
+            /^bearer /i,
+            /^basic /i,
+        ],
+        parentPatterns: [/auth/i, /security/i, /credential/i],
+    },
+    uncategorized: {
+        namePatterns: [],
+        valuePatterns: [],
+        parentPatterns: [],
+    },
+};
+/**
+ * Infer the category of a constant
+ */
+export function inferCategory(constant) {
+    const name = constant.name;
+    const value = String(constant.value ?? constant.rawValue ?? '');
+    const parentName = constant.parentName ?? '';
+    // Check each category in priority order
+    const priorityOrder = [
+        'security', // Security first - most important to flag
+        'feature_flag', // Feature flags are distinctive
+        'api', // API-related
+        'status', // Status values
+        'error', // Error codes
+        'limit', // Limits and thresholds
+        'config', // Configuration (after more specific categories)
+        'regex', // Regex patterns
+        'path', // File paths
+        'env', // Environment
+    ];
+    for (const category of priorityOrder) {
+        const patterns = CATEGORY_PATTERNS[category];
+        // Check name patterns
+        for (const pattern of patterns.namePatterns) {
+            if (pattern.test(name)) {
+                return category;
+            }
+        }
+        // Check value patterns
+        for (const pattern of patterns.valuePatterns) {
+            if (pattern.test(value)) {
+                return category;
+            }
+        }
+        // Check parent patterns
+        for (const pattern of patterns.parentPatterns) {
+            if (pattern.test(parentName)) {
+                return category;
+            }
+        }
+    }
+    return 'uncategorized';
+}
+/**
+ * Get category display name
+ */
+export function getCategoryDisplayName(category) {
+    const displayNames = {
+        config: 'Configuration',
+        api: 'API',
+        status: 'Status',
+        error: 'Error',
+        feature_flag: 'Feature Flag',
+        limit: 'Limit',
+        regex: 'Regex',
+        path: 'Path',
+        env: 'Environment',
+        security: 'Security',
+        uncategorized: 'Uncategorized',
+    };
+    return displayNames[category];
+}
+/**
+ * Get category description
+ */
+export function getCategoryDescription(category) {
+    const descriptions = {
+        config: 'Configuration values and settings',
+        api: 'API endpoints, URLs, headers, and related values',
+        status: 'Status codes, states, and phases',
+        error: 'Error codes and error messages',
+        feature_flag: 'Feature toggles and experiment flags',
+        limit: 'Limits, thresholds, timeouts, and sizes',
+        regex: 'Regular expression patterns',
+        path: 'File paths, routes, and directories',
+        env: 'Environment-related values',
+        security: 'Security-sensitive values (potential secrets)',
+        uncategorized: 'Constants that don\'t fit other categories',
+    };
+    return descriptions[category];
+}
+/**
+ * Check if a category is security-sensitive
+ */
+export function isSecuritySensitive(category) {
+    return category === 'security';
+}
+/**
+ * Suggest a better name for a constant based on its value
+ */
+export function suggestConstantName(value, category) {
+    const strValue = String(value);
+    // Common value-to-name mappings
+    const commonMappings = {
+        '3600': 'ONE_HOUR_SECONDS',
+        '86400': 'ONE_DAY_SECONDS',
+        '604800': 'ONE_WEEK_SECONDS',
+        '1000': 'ONE_SECOND_MS',
+        '60000': 'ONE_MINUTE_MS',
+        '3600000': 'ONE_HOUR_MS',
+        'application/json': 'CONTENT_TYPE_JSON',
+        'application/xml': 'CONTENT_TYPE_XML',
+        'text/html': 'CONTENT_TYPE_HTML',
+        'text/plain': 'CONTENT_TYPE_TEXT',
+        'utf-8': 'ENCODING_UTF8',
+        'utf8': 'ENCODING_UTF8',
+    };
+    const lowerValue = strValue.toLowerCase();
+    if (commonMappings[lowerValue]) {
+        return commonMappings[lowerValue];
+    }
+    // Generate name based on category and value
+    const prefix = getCategoryPrefix(category);
+    const sanitized = sanitizeForConstantName(strValue);
+    return `${prefix}${sanitized}`;
+}
+/**
+ * Get prefix for a category
+ */
+function getCategoryPrefix(category) {
+    const prefixes = {
+        config: 'CONFIG_',
+        api: 'API_',
+        status: 'STATUS_',
+        error: 'ERROR_',
+        feature_flag: 'FF_',
+        limit: 'MAX_',
+        regex: 'PATTERN_',
+        path: 'PATH_',
+        env: 'ENV_',
+        security: 'SECRET_',
+        uncategorized: '',
+    };
+    return prefixes[category];
+}
+/**
+ * Sanitize a value for use as a constant name
+ */
+function sanitizeForConstantName(value) {
+    return value
+        .toUpperCase()
+        .replace(/[^A-Z0-9]/g, '_')
+        .replace(/_+/g, '_')
+        .replace(/^_|_$/g, '')
+        .slice(0, 30);
+}
+//# sourceMappingURL=categorizer.js.map

package/dist/constants/analysis/categorizer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"categorizer.js","sourceRoot":"","sources":["../../../src/constants/analysis/categorizer.ts"],"names":[],"mappings":"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"}

package/dist/constants/analysis/consistency-analyzer.d.ts

@@ -0,0 +1,77 @@
+/**
+ * Constant Consistency Analyzer
+ *
+ * Detects inconsistent constants - same name with different values
+ * across the codebase.
+ */
+import type { ConstantExtraction, InconsistentConstant, ConstantCategory } from '../types.js';
+/**
+ * Configuration for consistency analysis
+ */
+export interface ConsistencyConfig {
+    /** Ignore case when comparing names */
+    ignoreCase: boolean;
+    /** Categories to analyze (empty = all) */
+    categories: ConstantCategory[];
+    /** File patterns to exclude */
+    excludePatterns: string[];
+    /** Minimum instances to report */
+    minInstances: number;
+}
+/**
+ * Default consistency config
+ */
+export declare const DEFAULT_CONSISTENCY_CONFIG: ConsistencyConfig;
+/**
+ * Result of consistency analysis
+ */
+export interface ConsistencyResult {
+    /** Inconsistent constants found */
+    inconsistencies: InconsistentConstant[];
+    /** Total constants analyzed */
+    totalAnalyzed: number;
+    /** Unique names analyzed */
+    uniqueNames: number;
+    /** Analysis time in ms */
+    analysisTimeMs: number;
+}
+/**
+ * Consistency analyzer
+ */
+export declare class ConsistencyAnalyzer {
+    private config;
+    constructor(config?: Partial<ConsistencyConfig>);
+    /**
+     * Analyze constants for inconsistencies
+     */
+    analyze(constants: ConstantExtraction[]): ConsistencyResult;
+    /**
+     * Group constants by name
+     */
+    private groupByName;
+    /**
+     * Find inconsistencies in grouped constants
+     */
+    private findInconsistencies;
+    /**
+     * Get unique values from constants
+     */
+    private getUniqueValues;
+    /**
+     * Normalize a value for comparison
+     */
+    private normalizeValue;
+    /**
+     * Generate a recommendation for fixing inconsistency
+     */
+    private generateRecommendation;
+    /**
+     * Check if a file should be excluded
+     */
+    private shouldExcludeFile;
+}
+/**
+ * Quick check for potential inconsistency
+ */
+export declare function hasPotentialInconsistency(constant: ConstantExtraction, existingConstants: ConstantExtraction[]): ConstantExtraction | null;
+//# sourceMappingURL=consistency-analyzer.d.ts.map

package/dist/constants/analysis/consistency-analyzer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"consistency-analyzer.d.ts","sourceRoot":"","sources":["../../../src/constants/analysis/consistency-analyzer.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EACV,kBAAkB,EAClB,oBAAoB,EAEpB,gBAAgB,EACjB,MAAM,aAAa,CAAC;AAErB;;GAEG;AACH,MAAM,WAAW,iBAAiB;IAChC,uCAAuC;IACvC,UAAU,EAAE,OAAO,CAAC;IACpB,0CAA0C;IAC1C,UAAU,EAAE,gBAAgB,EAAE,CAAC;IAC/B,+BAA+B;IAC/B,eAAe,EAAE,MAAM,EAAE,CAAC;IAC1B,kCAAkC;IAClC,YAAY,EAAE,MAAM,CAAC;CACtB;AAED;;GAEG;AACH,eAAO,MAAM,0BAA0B,EAAE,iBAKxC,CAAC;AAEF;;GAEG;AACH,MAAM,WAAW,iBAAiB;IAChC,mCAAmC;IACnC,eAAe,EAAE,oBAAoB,EAAE,CAAC;IACxC,+BAA+B;IAC/B,aAAa,EAAE,MAAM,CAAC;IACtB,4BAA4B;IAC5B,WAAW,EAAE,MAAM,CAAC;IACpB,0BAA0B;IAC1B,cAAc,EAAE,MAAM,CAAC;CACxB;AAED;;GAEG;AACH,qBAAa,mBAAmB;IAC9B,OAAO,CAAC,MAAM,CAAoB;gBAEtB,MAAM,GAAE,OAAO,CAAC,iBAAiB,CAAM;IAInD;;OAEG;IACH,OAAO,CAAC,SAAS,EAAE,kBAAkB,EAAE,GAAG,iBAAiB;IAgC3D;;OAEG;IACH,OAAO,CAAC,WAAW;IAgBnB;;OAEG;IACH,OAAO,CAAC,mBAAmB;IAyC3B;;OAEG;IACH,OAAO,CAAC,eAAe;IAWvB;;OAEG;IACH,OAAO,CAAC,cAAc;IAUtB;;OAEG;IACH,OAAO,CAAC,sBAAsB;IAmC9B;;OAEG;IACH,OAAO,CAAC,iBAAiB;CAQ1B;AAED;;GAEG;AACH,wBAAgB,yBAAyB,CACvC,QAAQ,EAAE,kBAAkB,EAC5B,iBAAiB,EAAE,kBAAkB,EAAE,GACtC,kBAAkB,GAAG,IAAI,CAW3B"}

package/dist/constants/analysis/consistency-analyzer.js

@@ -0,0 +1,176 @@
+/**
+ * Constant Consistency Analyzer
+ *
+ * Detects inconsistent constants - same name with different values
+ * across the codebase.
+ */
+/**
+ * Default consistency config
+ */
+export const DEFAULT_CONSISTENCY_CONFIG = {
+    ignoreCase: true,
+    categories: [], // All categories
+    minInstances: 2,
+    excludePatterns: ['node_modules', 'dist', 'build', '.git'],
+};
+/**
+ * Consistency analyzer
+ */
+export class ConsistencyAnalyzer {
+    config;
+    constructor(config = {}) {
+        this.config = { ...DEFAULT_CONSISTENCY_CONFIG, ...config };
+    }
+    /**
+     * Analyze constants for inconsistencies
+     */
+    analyze(constants) {
+        const startTime = performance.now();
+        // Filter constants
+        const filtered = constants.filter(c => {
+            // Exclude by file pattern
+            if (this.shouldExcludeFile(c.file)) {
+                return false;
+            }
+            // Filter by category if specified
+            if (this.config.categories.length > 0 && !this.config.categories.includes(c.category)) {
+                return false;
+            }
+            return true;
+        });
+        // Group by name
+        const byName = this.groupByName(filtered);
+        // Find inconsistencies
+        const inconsistencies = this.findInconsistencies(byName);
+        return {
+            inconsistencies,
+            totalAnalyzed: filtered.length,
+            uniqueNames: byName.size,
+            analysisTimeMs: performance.now() - startTime,
+        };
+    }
+    /**
+     * Group constants by name
+     */
+    groupByName(constants) {
+        const groups = new Map();
+        for (const constant of constants) {
+            const key = this.config.ignoreCase
+                ? constant.name.toLowerCase()
+                : constant.name;
+            const group = groups.get(key) || [];
+            group.push(constant);
+            groups.set(key, group);
+        }
+        return groups;
+    }
+    /**
+     * Find inconsistencies in grouped constants
+     */
+    findInconsistencies(groups) {
+        const inconsistencies = [];
+        for (const [name, constants] of groups) {
+            // Skip if not enough instances
+            if (constants.length < this.config.minInstances) {
+                continue;
+            }
+            // Check if values are different
+            const uniqueValues = this.getUniqueValues(constants);
+            if (uniqueValues.size <= 1) {
+                continue; // All same value, not inconsistent
+            }
+            // Build instances
+            const instances = constants.map(c => ({
+                id: c.id,
+                file: c.file,
+                line: c.line,
+                value: c.value ?? null,
+            }));
+            // Generate recommendation
+            const recommendation = this.generateRecommendation(name, constants, uniqueValues);
+            inconsistencies.push({
+                name: constants[0]?.name ?? name, // Use original case
+                instances,
+                recommendation,
+            });
+        }
+        // Sort by number of instances (most first)
+        inconsistencies.sort((a, b) => b.instances.length - a.instances.length);
+        return inconsistencies;
+    }
+    /**
+     * Get unique values from constants
+     */
+    getUniqueValues(constants) {
+        const values = new Set();
+        for (const constant of constants) {
+            const valueStr = this.normalizeValue(constant.value);
+            values.add(valueStr);
+        }
+        return values;
+    }
+    /**
+     * Normalize a value for comparison
+     */
+    normalizeValue(value) {
+        if (value === null || value === undefined) {
+            return 'null';
+        }
+        if (typeof value === 'string') {
+            return `"${value}"`;
+        }
+        return String(value);
+    }
+    /**
+     * Generate a recommendation for fixing inconsistency
+     */
+    generateRecommendation(name, constants, uniqueValues) {
+        const valueCount = uniqueValues.size;
+        const instanceCount = constants.length;
+        // Find most common value
+        const valueCounts = new Map();
+        for (const c of constants) {
+            const valueStr = this.normalizeValue(c.value);
+            valueCounts.set(valueStr, (valueCounts.get(valueStr) || 0) + 1);
+        }
+        let mostCommonValue = '';
+        let maxCount = 0;
+        for (const [value, count] of valueCounts) {
+            if (count > maxCount) {
+                maxCount = count;
+                mostCommonValue = value;
+            }
+        }
+        // Generate recommendation
+        if (valueCount === 2) {
+            return `Constant '${name}' has 2 different values across ${instanceCount} locations. ` +
+                `Consider standardizing to ${mostCommonValue} (used ${maxCount} times).`;
+        }
+        return `Constant '${name}' has ${valueCount} different values across ${instanceCount} locations. ` +
+            `Most common value is ${mostCommonValue} (used ${maxCount} times). ` +
+            `Consider consolidating into a single source of truth.`;
+    }
+    /**
+     * Check if a file should be excluded
+     */
+    shouldExcludeFile(filePath) {
+        for (const pattern of this.config.excludePatterns) {
+            if (filePath.includes(pattern)) {
+                return true;
+            }
+        }
+        return false;
+    }
+}
+/**
+ * Quick check for potential inconsistency
+ */
+export function hasPotentialInconsistency(constant, existingConstants) {
+    const sameName = existingConstants.find(c => c.name.toLowerCase() === constant.name.toLowerCase() &&
+        c.file !== constant.file);
+    if (sameName && sameName.value !== constant.value) {
+        return sameName;
+    }
+    return null;
+}
+//# sourceMappingURL=consistency-analyzer.js.map