@zgsm/costrict-cli 0.21.0-nightly.20251213.977248e09

package/dist/src/config/extensions/extensionEnablement.js

@@ -0,0 +1,190 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+import { coreEvents } from '@google/gemini-cli-core';
+import { ExtensionStorage } from './storage.js';
+export class Override {
+    baseRule;
+    isDisable;
+    includeSubdirs;
+    constructor(baseRule, isDisable, includeSubdirs) {
+        this.baseRule = baseRule;
+        this.isDisable = isDisable;
+        this.includeSubdirs = includeSubdirs;
+    }
+    static fromInput(inputRule, includeSubdirs) {
+        const isDisable = inputRule.startsWith('!');
+        let baseRule = isDisable ? inputRule.substring(1) : inputRule;
+        baseRule = ensureLeadingAndTrailingSlash(baseRule);
+        return new Override(baseRule, isDisable, includeSubdirs);
+    }
+    static fromFileRule(fileRule) {
+        const isDisable = fileRule.startsWith('!');
+        let baseRule = isDisable ? fileRule.substring(1) : fileRule;
+        const includeSubdirs = baseRule.endsWith('*');
+        baseRule = includeSubdirs
+            ? baseRule.substring(0, baseRule.length - 1)
+            : baseRule;
+        return new Override(baseRule, isDisable, includeSubdirs);
+    }
+    conflictsWith(other) {
+        if (this.baseRule === other.baseRule) {
+            return (this.includeSubdirs !== other.includeSubdirs ||
+                this.isDisable !== other.isDisable);
+        }
+        return false;
+    }
+    isEqualTo(other) {
+        return (this.baseRule === other.baseRule &&
+            this.includeSubdirs === other.includeSubdirs &&
+            this.isDisable === other.isDisable);
+    }
+    asRegex() {
+        return globToRegex(`${this.baseRule}${this.includeSubdirs ? '*' : ''}`);
+    }
+    isChildOf(parent) {
+        if (!parent.includeSubdirs) {
+            return false;
+        }
+        return parent.asRegex().test(this.baseRule);
+    }
+    output() {
+        return `${this.isDisable ? '!' : ''}${this.baseRule}${this.includeSubdirs ? '*' : ''}`;
+    }
+    matchesPath(path) {
+        return this.asRegex().test(path);
+    }
+}
+const ensureLeadingAndTrailingSlash = function (dirPath) {
+    // Normalize separators to forward slashes for consistent matching across platforms.
+    let result = dirPath.replace(/\\/g, '/');
+    if (result.charAt(0) !== '/') {
+        result = '/' + result;
+    }
+    if (result.charAt(result.length - 1) !== '/') {
+        result = result + '/';
+    }
+    return result;
+};
+/**
+ * Converts a glob pattern to a RegExp object.
+ * This is a simplified implementation that supports `*`.
+ *
+ * @param glob The glob pattern to convert.
+ * @returns A RegExp object.
+ */
+function globToRegex(glob) {
+    const regexString = glob
+        .replace(/[.+?^${}()|[\]\\]/g, '\\$&') // Escape special regex characters
+        .replace(/(\/?)\*/g, '($1.*)?'); // Convert * to optional group
+    return new RegExp(`^${regexString}$`);
+}
+export class ExtensionEnablementManager {
+    configFilePath;
+    configDir;
+    // If non-empty, this overrides all other extension configuration and enables
+    // only the ones in this list.
+    enabledExtensionNamesOverride;
+    constructor(enabledExtensionNames) {
+        this.configDir = ExtensionStorage.getUserExtensionsDir();
+        this.configFilePath = path.join(this.configDir, 'extension-enablement.json');
+        this.enabledExtensionNamesOverride =
+            enabledExtensionNames?.map((name) => name.toLowerCase()) ?? [];
+    }
+    validateExtensionOverrides(extensions) {
+        for (const name of this.enabledExtensionNamesOverride) {
+            if (name === 'none')
+                continue;
+            if (!extensions.some((ext) => ext.name.toLowerCase() === name.toLowerCase())) {
+                coreEvents.emitFeedback('error', `Extension not found: ${name}`);
+            }
+        }
+    }
+    /**
+     * Determines if an extension is enabled based on its name and the current
+     * path. The last matching rule in the overrides list wins.
+     *
+     * @param extensionName The name of the extension.
+     * @param currentPath The absolute path of the current working directory.
+     * @returns True if the extension is enabled, false otherwise.
+     */
+    isEnabled(extensionName, currentPath) {
+        // If we have a single override called 'none', this disables all extensions.
+        // Typically, this comes from the user passing `-e none`.
+        if (this.enabledExtensionNamesOverride.length === 1 &&
+            this.enabledExtensionNamesOverride[0] === 'none') {
+            return false;
+        }
+        // If we have explicit overrides, only enable those extensions.
+        if (this.enabledExtensionNamesOverride.length > 0) {
+            // When checking against overrides ONLY, we use a case insensitive match.
+            // The override names are already lowercased in the constructor.
+            return this.enabledExtensionNamesOverride.includes(extensionName.toLocaleLowerCase());
+        }
+        // Otherwise, we use the configuration settings
+        const config = this.readConfig();
+        const extensionConfig = config[extensionName];
+        // Extensions are enabled by default.
+        let enabled = true;
+        const allOverrides = extensionConfig?.overrides ?? [];
+        for (const rule of allOverrides) {
+            const override = Override.fromFileRule(rule);
+            if (override.matchesPath(ensureLeadingAndTrailingSlash(currentPath))) {
+                enabled = !override.isDisable;
+            }
+        }
+        return enabled;
+    }
+    readConfig() {
+        try {
+            const content = fs.readFileSync(this.configFilePath, 'utf-8');
+            return JSON.parse(content);
+        }
+        catch (error) {
+            if (error instanceof Error &&
+                'code' in error &&
+                error.code === 'ENOENT') {
+                return {};
+            }
+            coreEvents.emitFeedback('error', 'Failed to read extension enablement config.', error);
+            return {};
+        }
+    }
+    writeConfig(config) {
+        fs.mkdirSync(this.configDir, { recursive: true });
+        fs.writeFileSync(this.configFilePath, JSON.stringify(config, null, 2));
+    }
+    enable(extensionName, includeSubdirs, scopePath) {
+        const config = this.readConfig();
+        if (!config[extensionName]) {
+            config[extensionName] = { overrides: [] };
+        }
+        const override = Override.fromInput(scopePath, includeSubdirs);
+        const overrides = config[extensionName].overrides.filter((rule) => {
+            const fileOverride = Override.fromFileRule(rule);
+            if (fileOverride.conflictsWith(override) ||
+                fileOverride.isEqualTo(override)) {
+                return false; // Remove conflicts and equivalent values.
+            }
+            return !fileOverride.isChildOf(override);
+        });
+        overrides.push(override.output());
+        config[extensionName].overrides = overrides;
+        this.writeConfig(config);
+    }
+    disable(extensionName, includeSubdirs, scopePath) {
+        this.enable(extensionName, includeSubdirs, `!${scopePath}`);
+    }
+    remove(extensionName) {
+        const config = this.readConfig();
+        if (config[extensionName]) {
+            delete config[extensionName];
+            this.writeConfig(config);
+        }
+    }
+}
+//# sourceMappingURL=extensionEnablement.js.map

package/dist/src/config/extensions/extensionEnablement.js.map

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

package/dist/src/config/extensions/extensionEnablement.test.d.ts

@@ -0,0 +1,6 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+export {};

package/dist/src/config/extensions/extensionEnablement.test.js

@@ -0,0 +1,404 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import * as path from 'node:path';
+import fs from 'node:fs';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { ExtensionEnablementManager, Override } from './extensionEnablement.js';
+import { ExtensionStorage } from './storage.js';
+vi.mock('./storage.js');
+import { coreEvents, GEMINI_DIR, } from '@google/gemini-cli-core';
+vi.mock('node:os', () => ({
+    homedir: vi.fn().mockReturnValue('/virtual-home'),
+    tmpdir: vi.fn().mockReturnValue('/virtual-tmp'),
+}));
+const inMemoryFs = {};
+// Helper to create a temporary directory for testing
+function createTestDir() {
+    const dirPath = `/virtual-tmp/gemini-test-${Math.random().toString(36).substring(2, 15)}`;
+    inMemoryFs[dirPath] = ''; // Simulate directory existence
+    return {
+        path: dirPath,
+        cleanup: () => {
+            for (const key in inMemoryFs) {
+                if (key.startsWith(dirPath)) {
+                    delete inMemoryFs[key];
+                }
+            }
+        },
+    };
+}
+let testDir;
+let manager;
+describe('ExtensionEnablementManager', () => {
+    beforeEach(() => {
+        // Clear the in-memory file system before each test
+        for (const key in inMemoryFs) {
+            delete inMemoryFs[key];
+        }
+        expect(Object.keys(inMemoryFs).length).toBe(0); // Add this assertion
+        // Mock fs functions
+        vi.spyOn(fs, 'readFileSync').mockImplementation((path) => {
+            const content = inMemoryFs[path.toString()];
+            if (content === undefined) {
+                const error = new Error(`ENOENT: no such file or directory, open '${path}'`);
+                error.code = 'ENOENT';
+                throw error;
+            }
+            return content;
+        });
+        vi.spyOn(fs, 'writeFileSync').mockImplementation((path, data) => {
+            inMemoryFs[path.toString()] = data.toString(); // Convert ArrayBufferView to string for inMemoryFs
+        });
+        vi.spyOn(fs, 'mkdirSync').mockImplementation((_path, _options) => undefined);
+        vi.spyOn(fs, 'mkdtempSync').mockImplementation((prefix) => {
+            const virtualPath = `/virtual-tmp/${prefix.replace(/[^a-zA-Z0-9]/g, '')}`;
+            return virtualPath;
+        });
+        vi.spyOn(fs, 'rmSync').mockImplementation(() => { });
+        testDir = createTestDir();
+        vi.mocked(ExtensionStorage.getUserExtensionsDir).mockReturnValue(path.join(testDir.path, GEMINI_DIR));
+        manager = new ExtensionEnablementManager();
+    });
+    afterEach(() => {
+        vi.restoreAllMocks();
+        // Reset the singleton instance for test isolation
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        ExtensionEnablementManager.instance = undefined;
+    });
+    describe('isEnabled', () => {
+        it('should return true if extension is not configured', () => {
+            expect(manager.isEnabled('ext-test', '/any/path')).toBe(true);
+        });
+        it('should return true if no overrides match', () => {
+            manager.disable('ext-test', false, '/another/path');
+            expect(manager.isEnabled('ext-test', '/any/path')).toBe(true);
+        });
+        it('should enable a path based on an override rule', () => {
+            manager.disable('ext-test', true, '/');
+            manager.enable('ext-test', true, '/home/user/projects/');
+            expect(manager.isEnabled('ext-test', '/home/user/projects/my-app')).toBe(true);
+        });
+        it('should disable a path based on a disable override rule', () => {
+            manager.enable('ext-test', true, '/');
+            manager.disable('ext-test', true, '/home/user/projects/');
+            expect(manager.isEnabled('ext-test', '/home/user/projects/my-app')).toBe(false);
+        });
+        it('should respect the last matching rule (enable wins)', () => {
+            manager.disable('ext-test', true, '/home/user/projects/');
+            manager.enable('ext-test', false, '/home/user/projects/my-app');
+            expect(manager.isEnabled('ext-test', '/home/user/projects/my-app')).toBe(true);
+        });
+        it('should respect the last matching rule (disable wins)', () => {
+            manager.enable('ext-test', true, '/home/user/projects/');
+            manager.disable('ext-test', false, '/home/user/projects/my-app');
+            expect(manager.isEnabled('ext-test', '/home/user/projects/my-app')).toBe(false);
+        });
+        it('should handle overlapping rules correctly', () => {
+            manager.enable('ext-test', true, '/home/user/projects');
+            manager.disable('ext-test', false, '/home/user/projects/my-app');
+            expect(manager.isEnabled('ext-test', '/home/user/projects/my-app')).toBe(false);
+            expect(manager.isEnabled('ext-test', '/home/user/projects/something-else')).toBe(true);
+        });
+    });
+    describe('remove', () => {
+        it('should remove an extension from the config', () => {
+            manager.enable('ext-test', true, '/path/to/dir');
+            const config = manager.readConfig();
+            expect(config['ext-test']).toBeDefined();
+            manager.remove('ext-test');
+            const newConfig = manager.readConfig();
+            expect(newConfig['ext-test']).toBeUndefined();
+        });
+        it('should not throw when removing a non-existent extension', () => {
+            const config = manager.readConfig();
+            expect(config['ext-test']).toBeUndefined();
+            expect(() => manager.remove('ext-test')).not.toThrow();
+        });
+    });
+    describe('readConfig', () => {
+        it('should return an empty object if the config file is corrupted', () => {
+            const configPath = path.join(testDir.path, GEMINI_DIR, 'extension-enablement.json');
+            fs.mkdirSync(path.dirname(configPath), { recursive: true });
+            fs.writeFileSync(configPath, 'not a json');
+            const config = manager.readConfig();
+            expect(config).toEqual({});
+        });
+        it('should return an empty object on generic read error', () => {
+            vi.spyOn(fs, 'readFileSync').mockImplementation(() => {
+                throw new Error('Read error');
+            });
+            const config = manager.readConfig();
+            expect(config).toEqual({});
+        });
+    });
+    describe('includeSubdirs', () => {
+        it('should add a glob when enabling with includeSubdirs', () => {
+            manager.enable('ext-test', true, '/path/to/dir');
+            const config = manager.readConfig();
+            expect(config['ext-test'].overrides).toContain('/path/to/dir/*');
+        });
+        it('should not add a glob when enabling without includeSubdirs', () => {
+            manager.enable('ext-test', false, '/path/to/dir');
+            const config = manager.readConfig();
+            expect(config['ext-test'].overrides).toContain('/path/to/dir/');
+            expect(config['ext-test'].overrides).not.toContain('/path/to/dir/*');
+        });
+        it('should add a glob when disabling with includeSubdirs', () => {
+            manager.disable('ext-test', true, '/path/to/dir');
+            const config = manager.readConfig();
+            expect(config['ext-test'].overrides).toContain('!/path/to/dir/*');
+        });
+        it('should remove conflicting glob rule when enabling without subdirs', () => {
+            manager.enable('ext-test', true, '/path/to/dir'); // Adds /path/to/dir*
+            manager.enable('ext-test', false, '/path/to/dir'); // Should remove the glob
+            const config = manager.readConfig();
+            expect(config['ext-test'].overrides).toContain('/path/to/dir/');
+            expect(config['ext-test'].overrides).not.toContain('/path/to/dir/*');
+        });
+        it('should remove conflicting non-glob rule when enabling with subdirs', () => {
+            manager.enable('ext-test', false, '/path/to/dir'); // Adds /path/to/dir
+            manager.enable('ext-test', true, '/path/to/dir'); // Should remove the non-glob
+            const config = manager.readConfig();
+            expect(config['ext-test'].overrides).toContain('/path/to/dir/*');
+            expect(config['ext-test'].overrides).not.toContain('/path/to/dir/');
+        });
+        it('should remove conflicting rules when disabling', () => {
+            manager.enable('ext-test', true, '/path/to/dir'); // enabled with glob
+            manager.disable('ext-test', false, '/path/to/dir'); // disabled without
+            const config = manager.readConfig();
+            expect(config['ext-test'].overrides).toContain('!/path/to/dir/');
+            expect(config['ext-test'].overrides).not.toContain('/path/to/dir/*');
+        });
+        it('should correctly evaluate isEnabled with subdirs', () => {
+            manager.disable('ext-test', true, '/');
+            manager.enable('ext-test', true, '/path/to/dir');
+            expect(manager.isEnabled('ext-test', '/path/to/dir/')).toBe(true);
+            expect(manager.isEnabled('ext-test', '/path/to/dir/sub/')).toBe(true);
+            expect(manager.isEnabled('ext-test', '/path/to/another/')).toBe(false);
+        });
+        it('should correctly evaluate isEnabled without subdirs', () => {
+            manager.disable('ext-test', true, '/*');
+            manager.enable('ext-test', false, '/path/to/dir');
+            expect(manager.isEnabled('ext-test', '/path/to/dir')).toBe(true);
+            expect(manager.isEnabled('ext-test', '/path/to/dir/sub')).toBe(false);
+        });
+    });
+    describe('pruning child rules', () => {
+        it('should remove child rules when enabling a parent with subdirs', () => {
+            // Pre-existing rules for children
+            manager.enable('ext-test', false, '/path/to/dir/subdir1');
+            manager.disable('ext-test', true, '/path/to/dir/subdir2');
+            manager.enable('ext-test', false, '/path/to/another/dir');
+            // Enable the parent directory
+            manager.enable('ext-test', true, '/path/to/dir');
+            const config = manager.readConfig();
+            const overrides = config['ext-test'].overrides;
+            // The new parent rule should be present
+            expect(overrides).toContain(`/path/to/dir/*`);
+            // Child rules should be removed
+            expect(overrides).not.toContain('/path/to/dir/subdir1/');
+            expect(overrides).not.toContain(`!/path/to/dir/subdir2/*`);
+            // Unrelated rules should remain
+            expect(overrides).toContain('/path/to/another/dir/');
+        });
+        it('should remove child rules when disabling a parent with subdirs', () => {
+            // Pre-existing rules for children
+            manager.enable('ext-test', false, '/path/to/dir/subdir1');
+            manager.disable('ext-test', true, '/path/to/dir/subdir2');
+            manager.enable('ext-test', false, '/path/to/another/dir');
+            // Disable the parent directory
+            manager.disable('ext-test', true, '/path/to/dir');
+            const config = manager.readConfig();
+            const overrides = config['ext-test'].overrides;
+            // The new parent rule should be present
+            expect(overrides).toContain(`!/path/to/dir/*`);
+            // Child rules should be removed
+            expect(overrides).not.toContain('/path/to/dir/subdir1/');
+            expect(overrides).not.toContain(`!/path/to/dir/subdir2/*`);
+            // Unrelated rules should remain
+            expect(overrides).toContain('/path/to/another/dir/');
+        });
+        it('should not remove child rules if includeSubdirs is false', () => {
+            manager.enable('ext-test', false, '/path/to/dir/subdir1');
+            manager.enable('ext-test', false, '/path/to/dir'); // Not including subdirs
+            const config = manager.readConfig();
+            const overrides = config['ext-test'].overrides;
+            expect(overrides).toContain('/path/to/dir/subdir1/');
+            expect(overrides).toContain('/path/to/dir/');
+        });
+    });
+    it('should correctly prioritize more specific enable rules', () => {
+        manager.disable('ext-test', true, '/Users/chrstn');
+        manager.enable('ext-test', true, '/Users/chrstn/gemini-cli');
+        expect(manager.isEnabled('ext-test', '/Users/chrstn/gemini-cli')).toBe(true);
+    });
+    it('should not disable subdirectories if includeSubdirs is false', () => {
+        manager.disable('ext-test', false, '/Users/chrstn');
+        expect(manager.isEnabled('ext-test', '/Users/chrstn/gemini-cli')).toBe(true);
+    });
+    describe('extension overrides (-e <name>)', () => {
+        beforeEach(() => {
+            manager = new ExtensionEnablementManager(['ext-test']);
+        });
+        it('can enable extensions, case-insensitive', () => {
+            manager.disable('ext-test', true, '/');
+            expect(manager.isEnabled('ext-test', '/')).toBe(true);
+            expect(manager.isEnabled('Ext-Test', '/')).toBe(true);
+            // Double check that it would have been disabled otherwise
+            expect(new ExtensionEnablementManager().isEnabled('ext-test', '/')).toBe(false);
+        });
+        it('disable all other extensions', () => {
+            manager = new ExtensionEnablementManager(['ext-test']);
+            manager.enable('ext-test-2', true, '/');
+            expect(manager.isEnabled('ext-test-2', '/')).toBe(false);
+            // Double check that it would have been enabled otherwise
+            expect(new ExtensionEnablementManager().isEnabled('ext-test-2', '/')).toBe(true);
+        });
+        it('none disables all extensions', () => {
+            manager = new ExtensionEnablementManager(['none']);
+            manager.enable('ext-test', true, '/');
+            expect(manager.isEnabled('ext-test', '/path/to/dir')).toBe(false);
+            // Double check that it would have been enabled otherwise
+            expect(new ExtensionEnablementManager().isEnabled('ext-test', '/')).toBe(true);
+        });
+    });
+    describe('validateExtensionOverrides', () => {
+        let coreEventsEmitSpy;
+        beforeEach(() => {
+            coreEventsEmitSpy = vi.spyOn(coreEvents, 'emitFeedback');
+        });
+        afterEach(() => {
+            coreEventsEmitSpy.mockRestore();
+        });
+        it('should not log an error if enabledExtensionNamesOverride is empty', () => {
+            const manager = new ExtensionEnablementManager([]);
+            manager.validateExtensionOverrides([]);
+            expect(coreEventsEmitSpy).not.toHaveBeenCalled();
+        });
+        it('should not log an error if all enabledExtensionNamesOverride are valid', () => {
+            const manager = new ExtensionEnablementManager(['ext-one', 'ext-two']);
+            const extensions = [
+                { name: 'ext-one' },
+                { name: 'ext-two' },
+            ];
+            manager.validateExtensionOverrides(extensions);
+            expect(coreEventsEmitSpy).not.toHaveBeenCalled();
+        });
+        it('should log an error for each invalid extension name in enabledExtensionNamesOverride', () => {
+            const manager = new ExtensionEnablementManager([
+                'ext-one',
+                'ext-invalid',
+                'ext-another-invalid',
+            ]);
+            const extensions = [
+                { name: 'ext-one' },
+                { name: 'ext-two' },
+            ];
+            manager.validateExtensionOverrides(extensions);
+            expect(coreEventsEmitSpy).toHaveBeenCalledTimes(2);
+            expect(coreEventsEmitSpy).toHaveBeenCalledWith('error', 'Extension not found: ext-invalid');
+            expect(coreEventsEmitSpy).toHaveBeenCalledWith('error', 'Extension not found: ext-another-invalid');
+        });
+        it('should not log an error if "none" is in enabledExtensionNamesOverride', () => {
+            const manager = new ExtensionEnablementManager(['none']);
+            manager.validateExtensionOverrides([]);
+            expect(coreEventsEmitSpy).not.toHaveBeenCalled();
+        });
+    });
+});
+describe('Override', () => {
+    it('should create an override from input', () => {
+        const override = Override.fromInput('/path/to/dir', true);
+        expect(override.baseRule).toBe(`/path/to/dir/`);
+        expect(override.isDisable).toBe(false);
+        expect(override.includeSubdirs).toBe(true);
+    });
+    it('should create a disable override from input', () => {
+        const override = Override.fromInput('!/path/to/dir', false);
+        expect(override.baseRule).toBe(`/path/to/dir/`);
+        expect(override.isDisable).toBe(true);
+        expect(override.includeSubdirs).toBe(false);
+    });
+    it('should create an override from a file rule', () => {
+        const override = Override.fromFileRule('/path/to/dir/');
+        expect(override.baseRule).toBe('/path/to/dir/');
+        expect(override.isDisable).toBe(false);
+        expect(override.includeSubdirs).toBe(false);
+    });
+    it('should create an override from a file rule without a trailing slash', () => {
+        const override = Override.fromFileRule('/path/to/dir');
+        expect(override.baseRule).toBe('/path/to/dir');
+        expect(override.isDisable).toBe(false);
+        expect(override.includeSubdirs).toBe(false);
+    });
+    it('should create a disable override from a file rule', () => {
+        const override = Override.fromFileRule('!/path/to/dir/');
+        expect(override.isDisable).toBe(true);
+        expect(override.baseRule).toBe('/path/to/dir/');
+        expect(override.includeSubdirs).toBe(false);
+    });
+    it('should create an override with subdirs from a file rule', () => {
+        const override = Override.fromFileRule('/path/to/dir/*');
+        expect(override.baseRule).toBe('/path/to/dir/');
+        expect(override.isDisable).toBe(false);
+        expect(override.includeSubdirs).toBe(true);
+    });
+    it('should correctly identify conflicting overrides', () => {
+        const override1 = Override.fromInput('/path/to/dir', true);
+        const override2 = Override.fromInput('/path/to/dir', false);
+        expect(override1.conflictsWith(override2)).toBe(true);
+    });
+    it('should correctly identify non-conflicting overrides', () => {
+        const override1 = Override.fromInput('/path/to/dir', true);
+        const override2 = Override.fromInput('/path/to/another/dir', true);
+        expect(override1.conflictsWith(override2)).toBe(false);
+    });
+    it('should correctly identify equal overrides', () => {
+        const override1 = Override.fromInput('/path/to/dir', true);
+        const override2 = Override.fromInput('/path/to/dir', true);
+        expect(override1.isEqualTo(override2)).toBe(true);
+    });
+    it('should correctly identify unequal overrides', () => {
+        const override1 = Override.fromInput('/path/to/dir', true);
+        const override2 = Override.fromInput('!/path/to/dir', true);
+        expect(override1.isEqualTo(override2)).toBe(false);
+    });
+    it('should generate the correct regex', () => {
+        const override = Override.fromInput('/path/to/dir', true);
+        const regex = override.asRegex();
+        expect(regex.test('/path/to/dir/')).toBe(true);
+        expect(regex.test('/path/to/dir/subdir')).toBe(true);
+        expect(regex.test('/path/to/another/dir')).toBe(false);
+    });
+    it('should correctly identify child overrides', () => {
+        const parent = Override.fromInput('/path/to/dir', true);
+        const child = Override.fromInput('/path/to/dir/subdir', false);
+        expect(child.isChildOf(parent)).toBe(true);
+    });
+    it('should correctly identify child overrides with glob', () => {
+        const parent = Override.fromInput('/path/to/dir/*', true);
+        const child = Override.fromInput('/path/to/dir/subdir', false);
+        expect(child.isChildOf(parent)).toBe(true);
+    });
+    it('should correctly identify non-child overrides', () => {
+        const parent = Override.fromInput('/path/to/dir', true);
+        const other = Override.fromInput('/path/to/another/dir', false);
+        expect(other.isChildOf(parent)).toBe(false);
+    });
+    it('should generate the correct output string', () => {
+        const override = Override.fromInput('/path/to/dir', true);
+        expect(override.output()).toBe(`/path/to/dir/*`);
+    });
+    it('should generate the correct output string for a disable override', () => {
+        const override = Override.fromInput('!/path/to/dir', false);
+        expect(override.output()).toBe(`!/path/to/dir/`);
+    });
+    it('should disable a path based on a disable override rule', () => {
+        const override = Override.fromInput('!/path/to/dir', false);
+        expect(override.output()).toBe(`!/path/to/dir/`);
+    });
+});
+//# sourceMappingURL=extensionEnablement.test.js.map