guardrail-core 1.0.0

package/dist/__tests__/autopilot.test.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Autopilot Tests
+ *
+ * Tests for the Autopilot batch remediation feature.
+ */
+export {};
+//# sourceMappingURL=autopilot.test.d.ts.map

package/dist/__tests__/autopilot.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"autopilot.test.d.ts","sourceRoot":"","sources":["../../src/__tests__/autopilot.test.ts"],"names":[],"mappings":"AAAA;;;;GAIG"}

package/dist/__tests__/autopilot.test.js

@@ -0,0 +1,156 @@
+"use strict";
+/**
+ * Autopilot Tests
+ *
+ * Tests for the Autopilot batch remediation feature.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const autopilot_runner_1 = require("../autopilot/autopilot-runner");
+const types_1 = require("../autopilot/types");
+describe('AutopilotRunner', () => {
+    let runner;
+    beforeEach(() => {
+        runner = new autopilot_runner_1.AutopilotRunner();
+        process.env['GUARDRAIL_SKIP_ENTITLEMENTS'] = '1';
+    });
+    afterEach(() => {
+        delete process.env['GUARDRAIL_SKIP_ENTITLEMENTS'];
+    });
+    describe('groupIntoFixPacks', () => {
+        it('should group findings by category', () => {
+            const findings = [
+                { id: '1', category: 'type-errors', severity: 'high', file: 'a.ts', line: 1, message: 'err', fixable: true },
+                { id: '2', category: 'type-errors', severity: 'high', file: 'b.ts', line: 2, message: 'err', fixable: true },
+                { id: '3', category: 'quality', severity: 'low', file: 'c.ts', line: 3, message: 'console.log', fixable: true },
+            ];
+            const packs = runner.groupIntoFixPacks(findings);
+            expect(packs).toHaveLength(2);
+            const typeErrorsPack = packs.find(p => p.category === 'type-errors');
+            const qualityPack = packs.find(p => p.category === 'quality');
+            expect(typeErrorsPack).toBeDefined();
+            expect(qualityPack).toBeDefined();
+            expect(typeErrorsPack.findings).toHaveLength(2);
+            expect(qualityPack.findings).toHaveLength(1);
+        });
+        it('should exclude non-fixable findings', () => {
+            const findings = [
+                { id: '1', category: 'quality', severity: 'low', file: 'a.ts', line: 1, message: 'TODO', fixable: false },
+                { id: '2', category: 'quality', severity: 'low', file: 'b.ts', line: 2, message: 'console.log', fixable: true },
+            ];
+            const packs = runner.groupIntoFixPacks(findings);
+            expect(packs).toHaveLength(1);
+            expect(packs[0].findings).toHaveLength(1);
+            expect(packs[0].findings[0].id).toBe('2');
+        });
+        it('should respect maxFixes limit', () => {
+            const findings = Array.from({ length: 20 }, (_, i) => ({
+                id: String(i),
+                category: 'type-errors',
+                severity: 'high',
+                file: `file${i}.ts`,
+                line: i,
+                message: 'error',
+                fixable: true,
+            }));
+            const packs = runner.groupIntoFixPacks(findings, 5);
+            expect(packs).toHaveLength(1);
+            expect(packs[0].findings).toHaveLength(5);
+        });
+        it('should sort packs by priority', () => {
+            const findings = [
+                { id: '1', category: 'quality', severity: 'low', file: 'a.ts', line: 1, message: 'q', fixable: true },
+                { id: '2', category: 'security', severity: 'critical', file: 'b.ts', line: 2, message: 's', fixable: true },
+                { id: '3', category: 'type-errors', severity: 'high', file: 'c.ts', line: 3, message: 't', fixable: true },
+            ];
+            const packs = runner.groupIntoFixPacks(findings);
+            expect(packs[0].category).toBe('security');
+            expect(packs[1].category).toBe('type-errors');
+            expect(packs[2].category).toBe('quality');
+        });
+        it('should calculate risk based on severity', () => {
+            const lowSeverityFindings = [
+                { id: '1', category: 'quality', severity: 'low', file: 'a.ts', line: 1, message: 'q', fixable: true },
+            ];
+            const highSeverityFindings = [
+                { id: '2', category: 'security', severity: 'critical', file: 'b.ts', line: 2, message: 's', fixable: true },
+            ];
+            const lowPacks = runner.groupIntoFixPacks(lowSeverityFindings);
+            const highPacks = runner.groupIntoFixPacks(highSeverityFindings);
+            expect(lowPacks[0].estimatedRisk).toBe('low');
+            expect(highPacks[0].estimatedRisk).toBe('medium');
+        });
+        it('should collect impacted files without duplicates', () => {
+            const findings = [
+                { id: '1', category: 'type-errors', severity: 'high', file: 'a.ts', line: 1, message: 'err', fixable: true },
+                { id: '2', category: 'type-errors', severity: 'high', file: 'a.ts', line: 2, message: 'err', fixable: true },
+                { id: '3', category: 'type-errors', severity: 'high', file: 'b.ts', line: 1, message: 'err', fixable: true },
+            ];
+            const packs = runner.groupIntoFixPacks(findings);
+            expect(packs[0].impactedFiles).toHaveLength(2);
+            expect(packs[0].impactedFiles).toContain('a.ts');
+            expect(packs[0].impactedFiles).toContain('b.ts');
+        });
+        it('should return empty array when no fixable findings', () => {
+            const findings = [
+                { id: '1', category: 'quality', severity: 'low', file: 'a.ts', line: 1, message: 'TODO', fixable: false },
+            ];
+            const packs = runner.groupIntoFixPacks(findings);
+            expect(packs).toHaveLength(0);
+        });
+        it('should assign correct priority from FIX_PACK_PRIORITY', () => {
+            const findings = [
+                { id: '1', category: 'security', severity: 'high', file: 'a.ts', line: 1, message: 's', fixable: true },
+            ];
+            const packs = runner.groupIntoFixPacks(findings);
+            expect(packs[0].priority).toBe(types_1.AUTOPILOT_FIX_PACK_PRIORITY['security']);
+        });
+    });
+    describe('FIX_PACK_PRIORITY', () => {
+        it('should have security as highest priority', () => {
+            expect(types_1.AUTOPILOT_FIX_PACK_PRIORITY['security']).toBe(1);
+        });
+        it('should have quality as lowest priority', () => {
+            expect(types_1.AUTOPILOT_FIX_PACK_PRIORITY['quality']).toBe(7);
+        });
+        it('should have all categories defined', () => {
+            const categories = [
+                'security',
+                'build-blockers',
+                'type-errors',
+                'test-failures',
+                'route-integrity',
+                'placeholders',
+                'quality',
+            ];
+            for (const category of categories) {
+                expect(types_1.AUTOPILOT_FIX_PACK_PRIORITY[category]).toBeDefined();
+            }
+        });
+    });
+});
+describe('Autopilot Entitlement Gating', () => {
+    it('should require autopilot feature to be enabled', async () => {
+        const runner = new autopilot_runner_1.AutopilotRunner();
+        // Without GUARDRAIL_SKIP_ENTITLEMENTS, it should check entitlements
+        // In test environment without proper setup, it should fail gracefully
+        // This test verifies the entitlement check is wired up
+        delete process.env['GUARDRAIL_SKIP_ENTITLEMENTS'];
+        // The run method should attempt to check entitlements
+        // We expect it to either succeed (if entitlements pass) or fail with entitlement error
+        try {
+            await runner.run({
+                projectPath: process.cwd(),
+                mode: 'plan',
+            });
+            // If we get here, entitlements passed (e.g., in CI with proper config)
+        }
+        catch (error) {
+            // Expected to fail with entitlement-related error in test environment
+            expect(error.message.includes('autopilot') ||
+                error.message.includes('tier') ||
+                error.message.includes('feature') ||
+                error.message.includes('FEATURE_NOT_AVAILABLE') ||
+                error.code === 'FEATURE_NOT_AVAILABLE').toBe(true);
+        }
+    });
+});

package/dist/__tests__/tier-config.test.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Tier Configuration Drift Prevention Tests
+ *
+ * These tests ensure that tier definitions remain consistent across
+ * all parts of the codebase. If a tier is added/removed in one place
+ * but not others, these tests will fail.
+ */
+export {};
+//# sourceMappingURL=tier-config.test.d.ts.map

package/dist/__tests__/tier-config.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tier-config.test.d.ts","sourceRoot":"","sources":["../../src/__tests__/tier-config.test.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG"}

package/dist/__tests__/tier-config.test.js

@@ -0,0 +1,230 @@
+"use strict";
+/**
+ * Tier Configuration Drift Prevention Tests
+ *
+ * These tests ensure that tier definitions remain consistent across
+ * all parts of the codebase. If a tier is added/removed in one place
+ * but not others, these tests will fail.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const tier_config_1 = require("../tier-config");
+describe('Tier Configuration', () => {
+    describe('Tier Enum Consistency', () => {
+        it('should have exactly 6 tiers', () => {
+            expect(tier_config_1.TIERS).toHaveLength(6);
+        });
+        it('should include all required tiers', () => {
+            const requiredTiers = ['free', 'starter', 'pro', 'compliance', 'enterprise', 'unlimited'];
+            for (const tier of requiredTiers) {
+                expect(tier_config_1.TIERS).toContain(tier);
+            }
+        });
+        it('should have TIER_CONFIG for every tier in TIERS', () => {
+            for (const tier of tier_config_1.TIERS) {
+                expect(tier_config_1.TIER_CONFIG[tier]).toBeDefined();
+                expect(tier_config_1.TIER_CONFIG[tier].id).toBe(tier);
+                expect(tier_config_1.TIER_CONFIG[tier].name).toBeTruthy();
+            }
+        });
+        it('should have TIER_ORDER match TIERS', () => {
+            expect(tier_config_1.TIER_ORDER).toHaveLength(tier_config_1.TIERS.length);
+            for (const tier of tier_config_1.TIERS) {
+                expect(tier_config_1.TIER_ORDER).toContain(tier);
+            }
+        });
+        it('should have purchasable tiers be a subset of all tiers', () => {
+            for (const tier of tier_config_1.PURCHASABLE_TIERS) {
+                expect(tier_config_1.TIERS).toContain(tier);
+            }
+        });
+        it('should not include free or unlimited in purchasable tiers', () => {
+            expect(tier_config_1.PURCHASABLE_TIERS).not.toContain('free');
+            expect(tier_config_1.PURCHASABLE_TIERS).not.toContain('unlimited');
+        });
+    });
+    describe('Tier Configuration Completeness', () => {
+        it('should have all required fields for each tier', () => {
+            for (const tier of tier_config_1.TIERS) {
+                const config = tier_config_1.TIER_CONFIG[tier];
+                // Required fields
+                expect(config.id).toBe(tier);
+                expect(typeof config.name).toBe('string');
+                expect(typeof config.price).toBe('number');
+                expect(typeof config.annualPrice).toBe('number');
+                expect(typeof config.description).toBe('string');
+                expect(Array.isArray(config.features)).toBe(true);
+                // Limits
+                expect(typeof config.limits.scansPerMonth).toBe('number');
+                expect(typeof config.limits.realityRunsPerMonth).toBe('number');
+                expect(typeof config.limits.aiAgentRunsPerMonth).toBe('number');
+                expect(typeof config.limits.projects).toBe('number');
+                expect(typeof config.limits.teamMembers).toBe('number');
+                expect(typeof config.limits.complianceFrameworks).toBe('number');
+                // Rate limits
+                expect(typeof config.rateLimit.requestsPerMinute).toBe('number');
+                expect(typeof config.rateLimit.burstLimit).toBe('number');
+                expect(typeof config.rateLimit.windowMs).toBe('number');
+                // Upsell
+                expect(typeof config.upsell.message).toBe('string');
+                expect(tier_config_1.TIERS).toContain(config.upsell.nextTier);
+            }
+        });
+        it('should have features be valid Feature types', () => {
+            for (const tier of tier_config_1.TIERS) {
+                const config = tier_config_1.TIER_CONFIG[tier];
+                for (const feature of config.features) {
+                    expect(tier_config_1.FEATURES).toContain(feature);
+                }
+            }
+        });
+        it('should have increasing limits as tiers increase', () => {
+            const orderedTiers = ['free', 'starter', 'pro', 'compliance', 'enterprise'];
+            for (let i = 1; i < orderedTiers.length; i++) {
+                const prevTierKey = orderedTiers[i - 1];
+                const currTierKey = orderedTiers[i];
+                const prevTier = tier_config_1.TIER_CONFIG[prevTierKey];
+                const currTier = tier_config_1.TIER_CONFIG[currTierKey];
+                // Scans should increase or stay unlimited
+                if (prevTier.limits.scansPerMonth !== -1) {
+                    expect(currTier.limits.scansPerMonth).toBeGreaterThanOrEqual(prevTier.limits.scansPerMonth);
+                }
+            }
+        });
+        it('should have increasing rate limits as tiers increase', () => {
+            const orderedTiers = ['free', 'starter', 'pro', 'compliance', 'enterprise'];
+            for (let i = 1; i < orderedTiers.length; i++) {
+                const prevTierKey = orderedTiers[i - 1];
+                const currTierKey = orderedTiers[i];
+                const prevTier = tier_config_1.TIER_CONFIG[prevTierKey];
+                const currTier = tier_config_1.TIER_CONFIG[currTierKey];
+                expect(currTier.rateLimit.requestsPerMinute).toBeGreaterThanOrEqual(prevTier.rateLimit.requestsPerMinute);
+            }
+        });
+    });
+    describe('Pricing Consistency', () => {
+        it('should have free tier at $0', () => {
+            expect(tier_config_1.TIER_CONFIG.free.price).toBe(0);
+            expect(tier_config_1.TIER_CONFIG.free.annualPrice).toBe(0);
+        });
+        it('should have starter at $29/mo', () => {
+            expect(tier_config_1.TIER_CONFIG.starter.price).toBe(29);
+        });
+        it('should have pro at $99/mo', () => {
+            expect(tier_config_1.TIER_CONFIG.pro.price).toBe(99);
+        });
+        it('should have compliance at $199/mo', () => {
+            expect(tier_config_1.TIER_CONFIG.compliance.price).toBe(199);
+        });
+        it('should have annual pricing be exactly 20% off monthly*12', () => {
+            // IMPORTANT: This test ensures the "Save 20%" marketing claim is accurate.
+            // If this test fails, either:
+            // 1. Update annual prices to be exactly 20% off (monthly * 12 * 0.8)
+            // 2. Update the "Save 20%" copy in the UI to match the actual discount
+            const EXPECTED_DISCOUNT = 0.20; // 20% off
+            const TOLERANCE = 0.005; // Allow 0.5% tolerance for rounding
+            for (const tier of tier_config_1.PURCHASABLE_TIERS) {
+                const config = tier_config_1.TIER_CONFIG[tier];
+                if (config.price > 0) {
+                    const monthlyTotal = config.price * 12;
+                    const expectedAnnual = monthlyTotal * (1 - EXPECTED_DISCOUNT);
+                    const actualDiscount = (monthlyTotal - config.annualPrice) / monthlyTotal;
+                    // Assert the discount is within tolerance of 20%
+                    expect(actualDiscount).toBeGreaterThanOrEqual(EXPECTED_DISCOUNT - TOLERANCE);
+                    expect(actualDiscount).toBeLessThanOrEqual(EXPECTED_DISCOUNT + TOLERANCE);
+                    // Also verify the annual price is close to expected (within $2 for rounding)
+                    expect(config.annualPrice).toBeGreaterThanOrEqual(expectedAnnual - 2);
+                    expect(config.annualPrice).toBeLessThanOrEqual(expectedAnnual + 2);
+                }
+            }
+        });
+    });
+    describe('Helper Functions', () => {
+        it('isValidTier should validate tier strings', () => {
+            expect((0, tier_config_1.isValidTier)('free')).toBe(true);
+            expect((0, tier_config_1.isValidTier)('starter')).toBe(true);
+            expect((0, tier_config_1.isValidTier)('pro')).toBe(true);
+            expect((0, tier_config_1.isValidTier)('compliance')).toBe(true);
+            expect((0, tier_config_1.isValidTier)('enterprise')).toBe(true);
+            expect((0, tier_config_1.isValidTier)('unlimited')).toBe(true);
+            expect((0, tier_config_1.isValidTier)('invalid')).toBe(false);
+            expect((0, tier_config_1.isValidTier)('team')).toBe(false); // Legacy tier should not be valid
+        });
+        it('getTierConfig should return correct config', () => {
+            expect((0, tier_config_1.getTierConfig)('pro').name).toBe('Pro');
+            expect((0, tier_config_1.getTierConfig)('compliance').name).toBe('Compliance');
+        });
+        it('compareTiers should correctly order tiers', () => {
+            expect((0, tier_config_1.compareTiers)('free', 'pro')).toBeLessThan(0);
+            expect((0, tier_config_1.compareTiers)('pro', 'free')).toBeGreaterThan(0);
+            expect((0, tier_config_1.compareTiers)('pro', 'pro')).toBe(0);
+            expect((0, tier_config_1.compareTiers)('starter', 'compliance')).toBeLessThan(0);
+        });
+        it('isTierHigher should correctly compare tiers', () => {
+            expect((0, tier_config_1.isTierHigher)('pro', 'free')).toBe(true);
+            expect((0, tier_config_1.isTierHigher)('free', 'pro')).toBe(false);
+            expect((0, tier_config_1.isTierHigher)('compliance', 'starter')).toBe(true);
+        });
+        it('getMinimumTierForFeature should find correct tier', () => {
+            expect((0, tier_config_1.getMinimumTierForFeature)('scan')).toBe('free');
+            expect((0, tier_config_1.getMinimumTierForFeature)('reality')).toBe('starter');
+            expect((0, tier_config_1.getMinimumTierForFeature)('ai-agent')).toBe('pro');
+            expect((0, tier_config_1.getMinimumTierForFeature)('compliance:soc2')).toBe('compliance');
+        });
+        it('tierHasFeature should check features correctly', () => {
+            expect((0, tier_config_1.tierHasFeature)('free', 'scan')).toBe(true);
+            expect((0, tier_config_1.tierHasFeature)('free', 'reality')).toBe(false);
+            expect((0, tier_config_1.tierHasFeature)('starter', 'reality')).toBe(true);
+            expect((0, tier_config_1.tierHasFeature)('unlimited', 'compliance:soc2')).toBe(true);
+        });
+    });
+    describe('Pricing Page Integration', () => {
+        it('getPricingPageTiers should return 4 tiers for display', () => {
+            const pricingTiers = (0, tier_config_1.getPricingPageTiers)();
+            expect(pricingTiers).toHaveLength(4);
+        });
+        it('getPricingPageTiers should include free, starter, pro, compliance', () => {
+            const pricingTiers = (0, tier_config_1.getPricingPageTiers)();
+            const tierIds = pricingTiers.map(t => t.id);
+            expect(tierIds).toContain('free');
+            expect(tierIds).toContain('starter');
+            expect(tierIds).toContain('pro');
+            expect(tierIds).toContain('compliance');
+        });
+        it('getPricingPageTiers should mark pro as popular', () => {
+            const pricingTiers = (0, tier_config_1.getPricingPageTiers)();
+            const proTier = pricingTiers.find(t => t.id === 'pro');
+            expect(proTier?.popular).toBe(true);
+        });
+        it('getPricingPageTiers prices should match TIER_CONFIG', () => {
+            const pricingTiers = (0, tier_config_1.getPricingPageTiers)();
+            for (const tier of pricingTiers) {
+                const config = tier_config_1.TIER_CONFIG[tier.id];
+                expect(tier.price).toBe(config.price);
+                expect(tier.annual).toBe(config.annualPrice);
+                expect(tier.name).toBe(config.name);
+            }
+        });
+    });
+    describe('Rate Limiter Integration', () => {
+        it('getRateLimiterTiers should return config for all tiers', () => {
+            const rateLimiterTiers = (0, tier_config_1.getRateLimiterTiers)();
+            for (const tier of tier_config_1.TIERS) {
+                expect(rateLimiterTiers[tier]).toBeDefined();
+                expect(rateLimiterTiers[tier].name).toBe(tier_config_1.TIER_CONFIG[tier].name);
+                expect(rateLimiterTiers[tier].baseLimit).toBe(tier_config_1.TIER_CONFIG[tier].rateLimit.requestsPerMinute);
+                expect(rateLimiterTiers[tier].burstLimit).toBe(tier_config_1.TIER_CONFIG[tier].rateLimit.burstLimit);
+                expect(rateLimiterTiers[tier].windowMs).toBe(tier_config_1.TIER_CONFIG[tier].rateLimit.windowMs);
+            }
+        });
+    });
+    describe('No Legacy Tiers', () => {
+        it('should not have "team" tier (replaced by compliance)', () => {
+            expect(tier_config_1.TIERS).not.toContain('team');
+            expect(tier_config_1.TIER_CONFIG).not.toHaveProperty('team');
+        });
+        it('should not have "basic" tier', () => {
+            expect(tier_config_1.TIERS).not.toContain('basic');
+            expect(tier_config_1.TIER_CONFIG).not.toHaveProperty('basic');
+        });
+    });
+});

package/dist/__tests__/utils/hash-inline.test.d.ts

@@ -0,0 +1,2 @@
+declare const crypto: any;
+//# sourceMappingURL=hash-inline.test.d.ts.map

package/dist/__tests__/utils/hash-inline.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hash-inline.test.d.ts","sourceRoot":"","sources":["../../../src/__tests__/utils/hash-inline.test.ts"],"names":[],"mappings":"AAEA,QAAA,MAAM,MAAM,KAAyB,CAAC"}

package/dist/__tests__/utils/hash-inline.test.js

@@ -0,0 +1,62 @@
+"use strict";
+// @ts-nocheck
+/* eslint-disable @typescript-eslint/no-explicit-any */
+const crypto = require('node:crypto');
+// Inline hash function for testing
+function calculateHash(content) {
+    return crypto.createHash('sha256').update(content).digest('hex');
+}
+describe('Hash Utils', () => {
+    describe('calculateHash', () => {
+        it('should generate consistent hash for same input', () => {
+            const input = 'test-input';
+            const hash1 = calculateHash(input);
+            const hash2 = calculateHash(input);
+            expect(hash1).toBe(hash2);
+            expect(hash1).toMatch(/^[a-f0-9]{64}$/);
+        });
+        it('should generate different hashes for different inputs', () => {
+            const hash1 = calculateHash('input1');
+            const hash2 = calculateHash('input2');
+            expect(hash1).not.toBe(hash2);
+        });
+        it('should handle empty string', () => {
+            const hash = calculateHash('');
+            expect(hash).toMatch(/^[a-f0-9]{64}$/);
+        });
+        it('should handle special characters', () => {
+            const input = 'test with spaces and symbols !@#$%^&*()';
+            const hash = calculateHash(input);
+            expect(hash).toMatch(/^[a-f0-9]{64}$/);
+        });
+        it('should handle unicode characters', () => {
+            const input = '测试中文 🚀 emoji';
+            const hash = calculateHash(input);
+            expect(hash).toMatch(/^[a-f0-9]{64}$/);
+        });
+        it('should handle very long strings', () => {
+            const input = 'a'.repeat(10000);
+            const hash = calculateHash(input);
+            expect(hash).toMatch(/^[a-f0-9]{64}$/);
+        });
+    });
+    describe('Security Properties', () => {
+        it('should generate different hashes for similar inputs', () => {
+            const hash1 = calculateHash('password');
+            const hash2 = calculateHash('password ');
+            expect(hash1).not.toBe(hash2);
+        });
+        it('should be case-sensitive', () => {
+            const hash1 = calculateHash('Test');
+            const hash2 = calculateHash('test');
+            expect(hash1).not.toBe(hash2);
+        });
+        it('should produce fixed-length hashes', () => {
+            const inputs = ['a', 'abc', 'a long string with many characters'];
+            const hashes = inputs.map(calculateHash);
+            hashes.forEach(hash => {
+                expect(hash.length).toBe(64);
+            });
+        });
+    });
+});

package/dist/__tests__/utils/hash.test.d.ts

@@ -0,0 +1,3 @@
+declare const crypto: any;
+declare function verifyHash(input: any, hash: any): boolean;
+//# sourceMappingURL=hash.test.d.ts.map

package/dist/__tests__/utils/hash.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hash.test.d.ts","sourceRoot":"","sources":["../../../src/__tests__/utils/hash.test.ts"],"names":[],"mappings":"AAEA,QAAA,MAAM,MAAM,KAAyB,CAAC;AAQtC,iBAAS,UAAU,CAAC,KAAK,KAAA,EAAE,IAAI,KAAA,WAI9B"}

package/dist/__tests__/utils/hash.test.js

@@ -0,0 +1,95 @@
+"use strict";
+// @ts-nocheck
+/* eslint-disable @typescript-eslint/no-explicit-any */
+const crypto = require('node:crypto');
+// Hash function for testing
+function calculateHash(content) {
+    return crypto.createHash('sha256').update(content).digest('hex');
+}
+// Helper function to verify hash
+function verifyHash(input, hash) {
+    if (!input || !hash)
+        return false;
+    const calculatedHash = crypto.createHash('sha256').update(input).digest('hex');
+    return calculatedHash === hash;
+}
+describe('Hash Utils', () => {
+    describe('calculateHash', () => {
+        it('should generate consistent hash for same input', () => {
+            const input = 'test-input';
+            const hash1 = calculateHash(input);
+            const hash2 = calculateHash(input);
+            expect(hash1).toBe(hash2);
+            expect(hash1).toMatch(/^[a-f0-9]{64}$/);
+        });
+        it('should generate different hashes for different inputs', () => {
+            const hash1 = calculateHash('input1');
+            const hash2 = calculateHash('input2');
+            expect(hash1).not.toBe(hash2);
+        });
+        it('should handle empty string', () => {
+            const hash = calculateHash('');
+            expect(hash).toMatch(/^[a-f0-9]{64}$/);
+        });
+        it('should handle special characters', () => {
+            const input = 'test with spaces and symbols !@#$%^&*()';
+            const hash = calculateHash(input);
+            expect(hash).toMatch(/^[a-f0-9]{64}$/);
+        });
+        it('should handle unicode characters', () => {
+            const input = '测试中文 🚀 emoji';
+            const hash = calculateHash(input);
+            expect(hash).toMatch(/^[a-f0-9]{64}$/);
+        });
+        it('should handle very long strings', () => {
+            const input = 'a'.repeat(10000);
+            const hash = calculateHash(input);
+            expect(hash).toMatch(/^[a-f0-9]{64}$/);
+        });
+    });
+    describe('verifyHash', () => {
+        it('should verify correct hash', () => {
+            const input = 'test-input';
+            const hash = calculateHash(input);
+            expect(verifyHash(input, hash)).toBe(true);
+        });
+        it('should reject incorrect hash', () => {
+            const input = 'test-input';
+            const wrongHash = calculateHash('different-input');
+            expect(verifyHash(input, wrongHash)).toBe(false);
+        });
+        it('should reject empty hash', () => {
+            const input = 'test-input';
+            expect(verifyHash(input, '')).toBe(false);
+        });
+        it('should reject invalid hash format', () => {
+            const input = 'test-input';
+            const invalidHash = 'invalid-hash';
+            expect(verifyHash(input, invalidHash)).toBe(false);
+        });
+        it('should handle null/undefined inputs', () => {
+            const hash = calculateHash('test');
+            expect(verifyHash(null, hash)).toBe(false);
+            expect(verifyHash(undefined, hash)).toBe(false);
+        });
+    });
+    describe('Security Properties', () => {
+        it('should generate different hashes for similar inputs', () => {
+            const hash1 = calculateHash('password');
+            const hash2 = calculateHash('password ');
+            expect(hash1).not.toBe(hash2);
+        });
+        it('should be case-sensitive', () => {
+            const hash1 = calculateHash('Test');
+            const hash2 = calculateHash('test');
+            expect(hash1).not.toBe(hash2);
+        });
+        it('should produce fixed-length hashes', () => {
+            const inputs = ['a', 'abc', 'a long string with many characters'];
+            const hashes = inputs.map(calculateHash);
+            hashes.forEach(hash => {
+                expect(hash.length).toBe(64);
+            });
+        });
+    });
+});

package/dist/__tests__/utils/simple.test.d.ts

@@ -0,0 +1 @@
+//# sourceMappingURL=simple.test.d.ts.map

package/dist/__tests__/utils/simple.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"simple.test.d.ts","sourceRoot":"","sources":["../../../src/__tests__/utils/simple.test.ts"],"names":[],"mappings":""}

package/dist/__tests__/utils/simple.test.js

@@ -0,0 +1,10 @@
+"use strict";
+describe('Simple Test', () => {
+    it('should pass', () => {
+        expect(1 + 1).toBe(2);
+    });
+    it('should handle async', async () => {
+        await new Promise(resolve => setTimeout(resolve, 10));
+        expect(true).toBe(true);
+    });
+});

package/dist/__tests__/utils/utils-simple.test.d.ts

@@ -0,0 +1 @@
+//# sourceMappingURL=utils-simple.test.d.ts.map

package/dist/__tests__/utils/utils-simple.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils-simple.test.d.ts","sourceRoot":"","sources":["../../../src/__tests__/utils/utils-simple.test.ts"],"names":[],"mappings":""}

package/dist/__tests__/utils/utils-simple.test.js

@@ -0,0 +1,6 @@
+"use strict";
+describe("Simple Utils Test", () => {
+    it("should pass", () => {
+        expect(true).toBe(true);
+    });
+});

package/dist/__tests__/utils/utils.test.d.ts

@@ -0,0 +1,15 @@
+declare const crypto: any;
+declare function generateCorrelationId(): string;
+declare function generateTaskId(): string;
+declare function calculateEntropy(str: any): number;
+declare function maskSensitiveValue(value: any): string;
+declare function isPathAllowed(path: any, allowedPaths: any, deniedPaths: any): boolean;
+declare function isDomainAllowed(url: any, allowedDomains: any, deniedDomains: any): boolean;
+declare function sanitizeError(error: any): {
+    message: string;
+    code: any;
+} | {
+    message: string;
+    code?: undefined;
+};
+//# sourceMappingURL=utils.test.d.ts.map

package/dist/__tests__/utils/utils.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.test.d.ts","sourceRoot":"","sources":["../../../src/__tests__/utils/utils.test.ts"],"names":[],"mappings":"AAEA,QAAA,MAAM,MAAM,KAAyB,CAAC;AAGtC,iBAAS,qBAAqB,WAE7B;AAED,iBAAS,cAAc,WAEtB;AAMD,iBAAS,gBAAgB,CAAC,GAAG,KAAA,UAqB5B;AAED,iBAAS,kBAAkB,CAAC,KAAK,KAAA,UAKhC;AAED,iBAAS,aAAa,CAAC,IAAI,KAAA,EAAE,YAAY,KAAA,EAAE,WAAW,KAAA,WAuBrD;AAED,iBAAS,eAAe,CAAC,GAAG,KAAA,EAAE,cAAc,KAAA,EAAE,aAAa,KAAA,WA4B1D;AAED,iBAAS,aAAa,CAAC,KAAK,KAAA;;;;;;EAQ3B"}