@rigour-labs/core 2.9.4 → 2.11.0

package/dist/pattern-index/staleness.d.ts

@@ -0,0 +1,71 @@
+/**
+ * Staleness Detector
+ *
+ * Detects when AI is suggesting deprecated or outdated patterns.
+ * Uses package.json analysis and a deprecation database.
+ */
+import type { StalenessResult, StalenessIssue, DeprecationEntry } from './types.js';
+/**
+ * Project context extracted from package.json and other config files.
+ */
+interface ProjectContext {
+    dependencies: Record<string, string>;
+    devDependencies: Record<string, string>;
+    nodeVersion?: string;
+    typescriptVersion?: string;
+}
+/**
+ * Staleness Detector class.
+ */
+export declare class StalenessDetector {
+    private deprecations;
+    private projectContext;
+    private rootDir;
+    private remoteRulesUrl;
+    constructor(rootDir: string, customDeprecations?: DeprecationEntry[]);
+    /**
+     * Fetch latest deprecation rules from Rigour's remote registry.
+     * This ensures the tool stays up-to-date even without a package update.
+     */
+    syncRemoteRules(): Promise<number>;
+    /**
+     * Check NPM registry for live deprecation status of project dependencies.
+     * This is the ultimate "up-to-date" check.
+     */
+    checkLiveRegistry(context: ProjectContext): Promise<StalenessIssue[]>;
+    /**
+     * Load project context from package.json.
+     */
+    loadProjectContext(): Promise<ProjectContext>;
+    /**
+     * Check code for staleness issues.
+     */
+    checkStaleness(code: string, filePath?: string, options?: {
+        live?: boolean;
+    }): Promise<StalenessResult>;
+    /**
+     * Check if project has a library.
+     */
+    private hasLibrary;
+    /**
+     * Get installed version of a library.
+     */
+    private getInstalledVersion;
+    /**
+     * Add custom deprecation rules.
+     */
+    addDeprecation(entry: DeprecationEntry): void;
+    /**
+     * Load deprecations from a YAML file.
+     */
+    loadDeprecationsFromFile(filePath: string): Promise<void>;
+    /**
+     * Get all deprecations for display.
+     */
+    getAllDeprecations(): DeprecationEntry[];
+}
+/**
+ * Quick helper to check code for staleness.
+ */
+export declare function checkCodeStaleness(rootDir: string, code: string): Promise<StalenessResult>;
+export {};

package/dist/pattern-index/staleness.js

@@ -0,0 +1,381 @@
+/**
+ * Staleness Detector
+ *
+ * Detects when AI is suggesting deprecated or outdated patterns.
+ * Uses package.json analysis and a deprecation database.
+ */
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import semver from 'semver';
+/**
+ * Built-in deprecation database.
+ * This is bundled with Rigour and updated with releases.
+ */
+const BUILT_IN_DEPRECATIONS = [
+    // React deprecations
+    {
+        pattern: 'componentWillMount',
+        library: 'react',
+        deprecatedIn: '16.3.0',
+        replacement: 'useEffect(() => { ... }, [])',
+        severity: 'error',
+        reason: 'Unsafe lifecycle method removed in React 18',
+        docs: 'https://react.dev/reference/react/Component#unsafe_componentwillmount'
+    },
+    {
+        pattern: 'componentWillReceiveProps',
+        library: 'react',
+        deprecatedIn: '16.3.0',
+        replacement: 'getDerivedStateFromProps or useEffect',
+        severity: 'error',
+        reason: 'Unsafe lifecycle method removed in React 18'
+    },
+    {
+        pattern: 'componentWillUpdate',
+        library: 'react',
+        deprecatedIn: '16.3.0',
+        replacement: 'getSnapshotBeforeUpdate or useEffect',
+        severity: 'error',
+        reason: 'Unsafe lifecycle method removed in React 18'
+    },
+    {
+        pattern: 'UNSAFE_componentWillMount',
+        library: 'react',
+        deprecatedIn: '18.0.0',
+        replacement: 'useEffect(() => { ... }, [])',
+        severity: 'warning',
+        reason: 'Prepare for React 19 removal'
+    },
+    {
+        pattern: 'ReactDOM.render',
+        library: 'react-dom',
+        deprecatedIn: '18.0.0',
+        replacement: 'createRoot(container).render(<App />)',
+        severity: 'error',
+        reason: 'Legacy root API deprecated in React 18'
+    },
+    {
+        pattern: 'ReactDOM.hydrate',
+        library: 'react-dom',
+        deprecatedIn: '18.0.0',
+        replacement: 'hydrateRoot(container, <App />)',
+        severity: 'error',
+        reason: 'Legacy hydration API deprecated in React 18'
+    },
+    // Package deprecations
+    {
+        pattern: "import.*from ['\"]moment['\"]",
+        deprecatedIn: 'ecosystem',
+        replacement: "import { format } from 'date-fns'",
+        severity: 'warning',
+        reason: 'moment.js is in maintenance mode since September 2020',
+        docs: 'https://momentjs.com/docs/#/-project-status/'
+    },
+    {
+        pattern: "require\\(['\"]request['\"]\\)",
+        deprecatedIn: 'ecosystem',
+        replacement: 'Use native fetch or axios',
+        severity: 'error',
+        reason: 'request package deprecated in February 2020'
+    },
+    {
+        pattern: "import.*from ['\"]request['\"]",
+        deprecatedIn: 'ecosystem',
+        replacement: 'Use native fetch or axios',
+        severity: 'error',
+        reason: 'request package deprecated in February 2020'
+    },
+    // JavaScript/TypeScript deprecations
+    {
+        pattern: '\\bvar\\s+\\w+\\s*=',
+        deprecatedIn: 'es6',
+        replacement: 'Use const or let',
+        severity: 'warning',
+        reason: 'var has function scope which leads to bugs. Use block-scoped const/let'
+    },
+    // Redux deprecations
+    {
+        pattern: 'createStore\\(',
+        library: 'redux',
+        deprecatedIn: '4.2.0',
+        replacement: "configureStore from '@reduxjs/toolkit'",
+        severity: 'warning',
+        reason: 'Redux Toolkit is now the recommended way',
+        docs: 'https://redux.js.org/introduction/why-rtk-is-redux-today'
+    },
+    // Node.js deprecations
+    {
+        pattern: 'new Buffer\\(',
+        deprecatedIn: 'node@6.0.0',
+        replacement: 'Buffer.alloc() or Buffer.from()',
+        severity: 'error',
+        reason: 'Buffer constructor is a security hazard'
+    },
+    // Express deprecations
+    {
+        pattern: 'app\\.del\\(',
+        library: 'express',
+        deprecatedIn: '4.0.0',
+        replacement: 'app.delete()',
+        severity: 'warning',
+        reason: 'app.del() was renamed to app.delete()'
+    },
+    // TypeScript patterns to avoid
+    {
+        pattern: '\\benum\\s+\\w+',
+        deprecatedIn: 'best-practice',
+        replacement: 'const object with as const assertion',
+        severity: 'info',
+        reason: 'Enums have quirks. Consider using const objects for better tree-shaking',
+        docs: 'https://www.typescriptlang.org/docs/handbook/enums.html#const-enums'
+    },
+    // Next.js deprecations
+    {
+        pattern: 'getInitialProps',
+        library: 'next',
+        deprecatedIn: '13.0.0',
+        replacement: 'getServerSideProps or App Router with async components',
+        severity: 'warning',
+        reason: 'getInitialProps prevents static optimization'
+    },
+    {
+        pattern: "from ['\"]next/router['\"]",
+        library: 'next',
+        deprecatedIn: '13.0.0',
+        replacement: "useRouter from 'next/navigation' in App Router",
+        severity: 'info',
+        reason: 'Use next/navigation for App Router projects'
+    }
+];
+/**
+ * Staleness Detector class.
+ */
+export class StalenessDetector {
+    deprecations;
+    projectContext = null;
+    rootDir;
+    remoteRulesUrl = 'https://raw.githubusercontent.com/rigour-labs/rules/main/deprecations.json';
+    constructor(rootDir, customDeprecations = []) {
+        this.rootDir = rootDir;
+        this.deprecations = [...BUILT_IN_DEPRECATIONS, ...customDeprecations];
+    }
+    /**
+     * Fetch latest deprecation rules from Rigour's remote registry.
+     * This ensures the tool stays up-to-date even without a package update.
+     */
+    async syncRemoteRules() {
+        try {
+            // Using dynamic import for fetch to avoid Node < 18 issues
+            const response = await fetch(this.remoteRulesUrl);
+            if (!response.ok)
+                throw new Error(`HTTP error! status: ${response.status}`);
+            const data = await response.json();
+            if (data.deprecations && Array.isArray(data.deprecations)) {
+                // Merge remote rules, avoiding duplicates
+                const existingPatterns = new Set(this.deprecations.map(d => d.pattern));
+                const newRules = data.deprecations.filter((d) => !existingPatterns.has(d.pattern));
+                this.deprecations.push(...newRules);
+                return newRules.length;
+            }
+            return 0;
+        }
+        catch (error) {
+            console.warn('Failed to sync remote rules, using built-in database:', error);
+            return 0;
+        }
+    }
+    /**
+     * Check NPM registry for live deprecation status of project dependencies.
+     * This is the ultimate "up-to-date" check.
+     */
+    async checkLiveRegistry(context) {
+        const issues = [];
+        const { execa } = await import('execa');
+        // We only check top-level dependencies to avoid noise/performance hits
+        const deps = Object.keys(context.dependencies);
+        for (const dep of deps) {
+            try {
+                // Run 'npm info <package> --json' to get metadata
+                const { stdout } = await execa('npm', ['info', dep, '--json']);
+                const info = JSON.parse(stdout);
+                // 1. Check if package is deprecated
+                if (info.deprecated) {
+                    issues.push({
+                        line: 0, // Package-level
+                        pattern: dep,
+                        severity: 'error',
+                        reason: `Package "${dep}" is marked as DEPRECATED in NPM registry: ${info.deprecated}`,
+                        replacement: 'Check package README for suggested alternatives',
+                        docs: `https://www.npmjs.com/package/${dep}`
+                    });
+                }
+                // 2. Check for latest version staleness
+                const current = context.dependencies[dep].replace(/^[\^~>=<]+/, '');
+                const latest = info['dist-tags']?.latest;
+                if (latest && semver.major(latest) > semver.major(current)) {
+                    issues.push({
+                        line: 0,
+                        pattern: dep,
+                        severity: 'info',
+                        reason: `Package "${dep}" has a new major version available (${latest}). Your version: ${current}`,
+                        replacement: `npm install ${dep}@latest`,
+                        docs: `https://www.npmjs.com/package/${dep}`
+                    });
+                }
+            }
+            catch (error) {
+                // Silently skip if npm check fails
+                continue;
+            }
+        }
+        return issues;
+    }
+    /**
+     * Load project context from package.json.
+     */
+    async loadProjectContext() {
+        if (this.projectContext) {
+            return this.projectContext;
+        }
+        const pkgPath = path.join(this.rootDir, 'package.json');
+        try {
+            const content = await fs.readFile(pkgPath, 'utf-8');
+            const pkg = JSON.parse(content);
+            this.projectContext = {
+                dependencies: pkg.dependencies || {},
+                devDependencies: pkg.devDependencies || {},
+                nodeVersion: pkg.engines?.node,
+                typescriptVersion: (pkg.devDependencies?.typescript || pkg.dependencies?.typescript)
+            };
+            return this.projectContext;
+        }
+        catch {
+            this.projectContext = {
+                dependencies: {},
+                devDependencies: {}
+            };
+            return this.projectContext;
+        }
+    }
+    /**
+     * Check code for staleness issues.
+     */
+    async checkStaleness(code, filePath, options = {}) {
+        const context = await this.loadProjectContext();
+        const issues = [];
+        // 1. Check built-in/remote rules
+        const lines = code.split('\n');
+        for (const deprecation of this.deprecations) {
+            // Check if this deprecation applies to the project
+            if (deprecation.library && !this.hasLibrary(deprecation.library, context)) {
+                continue;
+            }
+            // Check version constraints
+            if (deprecation.library && deprecation.deprecatedIn !== 'ecosystem' &&
+                deprecation.deprecatedIn !== 'best-practice' &&
+                deprecation.deprecatedIn !== 'es6') {
+                const installed = this.getInstalledVersion(deprecation.library, context);
+                if (installed && !semver.gte(semver.coerce(installed) || '0.0.0', semver.coerce(deprecation.deprecatedIn) || '0.0.0')) {
+                    // Project is on older version where this isn't deprecated yet
+                    continue;
+                }
+            }
+            // Check for pattern match
+            const regex = new RegExp(deprecation.pattern, 'g');
+            for (let i = 0; i < lines.length; i++) {
+                if (regex.test(lines[i])) {
+                    issues.push({
+                        line: i + 1,
+                        pattern: deprecation.pattern,
+                        severity: deprecation.severity,
+                        reason: deprecation.reason || `Deprecated in ${deprecation.deprecatedIn}`,
+                        replacement: deprecation.replacement,
+                        docs: deprecation.docs
+                    });
+                }
+                regex.lastIndex = 0;
+            }
+        }
+        // 2. Perform live registry check if requested (only once per run/file usually)
+        if (options.live) {
+            const liveIssues = await this.checkLiveRegistry(context);
+            issues.push(...liveIssues);
+        }
+        // Determine overall status
+        let status = 'FRESH';
+        if (issues.some(i => i.severity === 'error')) {
+            status = 'DEPRECATED';
+        }
+        else if (issues.some(i => i.severity === 'warning')) {
+            status = 'STALE';
+        }
+        // Build project context for response
+        const projectContextOutput = {};
+        for (const [name, version] of Object.entries(context.dependencies)) {
+            if (['react', 'react-dom', 'next', 'typescript', 'redux', 'express'].includes(name)) {
+                projectContextOutput[name] = version;
+            }
+        }
+        for (const [name, version] of Object.entries(context.devDependencies)) {
+            if (['typescript'].includes(name)) {
+                projectContextOutput[name] = version;
+            }
+        }
+        return {
+            status,
+            issues,
+            projectContext: projectContextOutput
+        };
+    }
+    /**
+     * Check if project has a library.
+     */
+    hasLibrary(library, context) {
+        return library in context.dependencies || library in context.devDependencies;
+    }
+    /**
+     * Get installed version of a library.
+     */
+    getInstalledVersion(library, context) {
+        const version = context.dependencies[library] || context.devDependencies[library];
+        if (!version)
+            return null;
+        // Remove version prefix (^, ~, >=, etc.)
+        return version.replace(/^[\^~>=<]+/, '');
+    }
+    /**
+     * Add custom deprecation rules.
+     */
+    addDeprecation(entry) {
+        this.deprecations.push(entry);
+    }
+    /**
+     * Load deprecations from a YAML file.
+     */
+    async loadDeprecationsFromFile(filePath) {
+        try {
+            const content = await fs.readFile(filePath, 'utf-8');
+            const { parse } = await import('yaml');
+            const data = parse(content);
+            if (data.deprecations && Array.isArray(data.deprecations)) {
+                this.deprecations.push(...data.deprecations);
+            }
+        }
+        catch (error) {
+            console.error(`Failed to load deprecations from ${filePath}:`, error);
+        }
+    }
+    /**
+     * Get all deprecations for display.
+     */
+    getAllDeprecations() {
+        return [...this.deprecations];
+    }
+}
+/**
+ * Quick helper to check code for staleness.
+ */
+export async function checkCodeStaleness(rootDir, code) {
+    const detector = new StalenessDetector(rootDir);
+    return detector.checkStaleness(code);
+}

package/dist/pattern-index/staleness.test.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Staleness Detector Tests
+ *
+ * Tests for the staleness detection system.
+ */
+export {};

package/dist/pattern-index/staleness.test.js

@@ -0,0 +1,211 @@
+/**
+ * Staleness Detector Tests
+ *
+ * Tests for the staleness detection system.
+ */
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import * as os from 'os';
+import { StalenessDetector, checkCodeStaleness } from './staleness.js';
+describe('StalenessDetector', () => {
+    let testDir;
+    beforeEach(async () => {
+        testDir = await fs.mkdtemp(path.join(os.tmpdir(), 'rigour-staleness-'));
+    });
+    afterEach(async () => {
+        await fs.rm(testDir, { recursive: true, force: true });
+    });
+    describe('React deprecations', () => {
+        it('should detect componentWillMount', async () => {
+            await fs.writeFile(path.join(testDir, 'package.json'), JSON.stringify({ dependencies: { react: '^18.0.0' } }));
+            const detector = new StalenessDetector(testDir);
+            const result = await detector.checkStaleness(`
+                class MyComponent extends React.Component {
+                    componentWillMount() {
+                        console.log('mounting');
+                    }
+                }
+            `);
+            expect(result.status).toBe('DEPRECATED');
+            expect(result.issues.some(i => i.pattern.includes('componentWillMount'))).toBe(true);
+            expect(result.issues[0].replacement).toContain('useEffect');
+        });
+        it('should detect ReactDOM.render', async () => {
+            await fs.writeFile(path.join(testDir, 'package.json'), JSON.stringify({ dependencies: { react: '^18.0.0', 'react-dom': '^18.0.0' } }));
+            const detector = new StalenessDetector(testDir);
+            const result = await detector.checkStaleness(`
+                ReactDOM.render(<App />, document.getElementById('root'));
+            `);
+            expect(result.status).toBe('DEPRECATED');
+            expect(result.issues.some(i => i.pattern.includes('ReactDOM.render'))).toBe(true);
+            expect(result.issues[0].replacement).toContain('createRoot');
+        });
+        it('should not flag React deprecations if React is not installed', async () => {
+            await fs.writeFile(path.join(testDir, 'package.json'), JSON.stringify({ dependencies: { express: '^4.0.0' } }));
+            const detector = new StalenessDetector(testDir);
+            const result = await detector.checkStaleness(`
+                componentWillMount() {}
+            `);
+            // Should not flag React-specific patterns if React isn't a dependency
+            expect(result.issues.filter(i => i.pattern.includes('componentWillMount'))).toHaveLength(0);
+        });
+    });
+    describe('Package deprecations', () => {
+        it('should detect moment.js usage', async () => {
+            await fs.writeFile(path.join(testDir, 'package.json'), JSON.stringify({ dependencies: {} }));
+            const detector = new StalenessDetector(testDir);
+            const result = await detector.checkStaleness(`
+                import moment from 'moment';
+                const date = moment().format('YYYY-MM-DD');
+            `);
+            expect(result.status).toBe('STALE');
+            expect(result.issues.some(i => i.replacement.includes('date-fns'))).toBe(true);
+        });
+        it('should detect request library usage', async () => {
+            await fs.writeFile(path.join(testDir, 'package.json'), JSON.stringify({ dependencies: {} }));
+            const detector = new StalenessDetector(testDir);
+            const result = await detector.checkStaleness(`
+                const request = require('request');
+                request.get('https://example.com');
+            `);
+            expect(result.status).toBe('DEPRECATED');
+            expect(result.issues.some(i => i.replacement.includes('fetch'))).toBe(true);
+        });
+    });
+    describe('JavaScript deprecations', () => {
+        it('should detect var keyword usage', async () => {
+            await fs.writeFile(path.join(testDir, 'package.json'), JSON.stringify({ dependencies: {} }));
+            const detector = new StalenessDetector(testDir);
+            const result = await detector.checkStaleness(`
+                var name = 'test';
+                var count = 0;
+            `);
+            expect(result.issues.some(i => i.replacement.includes('const') || i.replacement.includes('let'))).toBe(true);
+        });
+    });
+    describe('Redux deprecations', () => {
+        it('should detect createStore usage in modern Redux projects', async () => {
+            await fs.writeFile(path.join(testDir, 'package.json'), JSON.stringify({ dependencies: { redux: '^4.2.0' } }));
+            const detector = new StalenessDetector(testDir);
+            const result = await detector.checkStaleness(`
+                import { createStore } from 'redux';
+                const store = createStore(reducer);
+            `);
+            expect(result.status).toBe('STALE');
+            expect(result.issues.some(i => i.replacement.includes('configureStore'))).toBe(true);
+        });
+    });
+    describe('Node.js deprecations', () => {
+        it('should detect Buffer constructor', async () => {
+            await fs.writeFile(path.join(testDir, 'package.json'), JSON.stringify({ dependencies: {} }));
+            const detector = new StalenessDetector(testDir);
+            const result = await detector.checkStaleness(`
+                const buf = new Buffer('hello');
+            `);
+            expect(result.status).toBe('DEPRECATED');
+            expect(result.issues.some(i => i.replacement.includes('Buffer.from'))).toBe(true);
+        });
+    });
+    describe('Next.js deprecations', () => {
+        it('should detect getInitialProps in Next 13+ projects', async () => {
+            await fs.writeFile(path.join(testDir, 'package.json'), JSON.stringify({ dependencies: { next: '^13.0.0' } }));
+            const detector = new StalenessDetector(testDir);
+            const result = await detector.checkStaleness(`
+                MyPage.getInitialProps = async (ctx) => {
+                    return { data: {} };
+                };
+            `);
+            expect(result.issues.some(i => i.pattern.includes('getInitialProps'))).toBe(true);
+        });
+    });
+    describe('TypeScript best practices', () => {
+        it('should warn about enum usage', async () => {
+            await fs.writeFile(path.join(testDir, 'package.json'), JSON.stringify({ dependencies: {} }));
+            const detector = new StalenessDetector(testDir);
+            const result = await detector.checkStaleness(`
+                enum Status {
+                    Active = 'active',
+                    Inactive = 'inactive'
+                }
+            `);
+            expect(result.issues.some(i => i.severity === 'info' && i.pattern.includes('enum'))).toBe(true);
+        });
+    });
+    describe('Project context', () => {
+        it('should return project versions in context', async () => {
+            await fs.writeFile(path.join(testDir, 'package.json'), JSON.stringify({
+                dependencies: {
+                    react: '^18.2.0',
+                    next: '^14.0.0'
+                },
+                devDependencies: {
+                    typescript: '^5.0.0'
+                }
+            }));
+            const detector = new StalenessDetector(testDir);
+            const result = await detector.checkStaleness('const x = 1;');
+            expect(result.projectContext.react).toBeDefined();
+            expect(result.projectContext.next).toBeDefined();
+            expect(result.projectContext.typescript).toBeDefined();
+        });
+    });
+    describe('Custom deprecations', () => {
+        it('should allow adding custom deprecation rules', async () => {
+            await fs.writeFile(path.join(testDir, 'package.json'), JSON.stringify({ dependencies: {} }));
+            const detector = new StalenessDetector(testDir);
+            detector.addDeprecation({
+                pattern: 'legacyFunction',
+                deprecatedIn: '1.0.0',
+                replacement: 'newFunction()',
+                severity: 'error',
+                reason: 'Custom deprecation'
+            });
+            const result = await detector.checkStaleness(`
+                legacyFunction();
+            `);
+            expect(result.issues.some(i => i.replacement === 'newFunction()')).toBe(true);
+        });
+    });
+    describe('Overall status', () => {
+        it('should return FRESH when no issues found', async () => {
+            await fs.writeFile(path.join(testDir, 'package.json'), JSON.stringify({ dependencies: {} }));
+            const detector = new StalenessDetector(testDir);
+            const result = await detector.checkStaleness(`
+                const name = 'test';
+                const greet = () => console.log('Hello');
+            `);
+            expect(result.status).toBe('FRESH');
+        });
+        it('should return STALE for warnings', async () => {
+            await fs.writeFile(path.join(testDir, 'package.json'), JSON.stringify({ dependencies: { redux: '^4.2.0' } }));
+            const detector = new StalenessDetector(testDir);
+            const result = await detector.checkStaleness(`
+                createStore(reducer);
+            `);
+            expect(result.status).toBe('STALE');
+        });
+        it('should return DEPRECATED for errors', async () => {
+            await fs.writeFile(path.join(testDir, 'package.json'), JSON.stringify({ dependencies: {} }));
+            const detector = new StalenessDetector(testDir);
+            const result = await detector.checkStaleness(`
+                new Buffer('hello');
+            `);
+            expect(result.status).toBe('DEPRECATED');
+        });
+    });
+});
+describe('checkCodeStaleness', () => {
+    let testDir;
+    beforeEach(async () => {
+        testDir = await fs.mkdtemp(path.join(os.tmpdir(), 'rigour-staleness-'));
+        await fs.writeFile(path.join(testDir, 'package.json'), JSON.stringify({ dependencies: {} }));
+    });
+    afterEach(async () => {
+        await fs.rm(testDir, { recursive: true, force: true });
+    });
+    it('should be a quick helper for staleness checking', async () => {
+        const result = await checkCodeStaleness(testDir, 'const x = 1;');
+        expect(result.status).toBe('FRESH');
+    });
+});