@smallironman/mcp-memory-keeper 0.12.2-fork1

package/dist/__tests__/utils/token-limits.test.js

@@ -0,0 +1,225 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const token_limits_1 = require("../../utils/token-limits");
+describe('Token Limit Utilities', () => {
+    describe('estimateTokens', () => {
+        it('should estimate tokens more conservatively than before', () => {
+            const text = 'This is a test string';
+            const tokens = (0, token_limits_1.estimateTokens)(text);
+            // Using 3.5 chars per token instead of 4
+            expect(tokens).toBe(Math.ceil(text.length / 3.5));
+        });
+        it('should handle empty strings', () => {
+            expect((0, token_limits_1.estimateTokens)('')).toBe(0);
+        });
+        it('should handle large texts', () => {
+            const largeText = 'x'.repeat(10000);
+            const tokens = (0, token_limits_1.estimateTokens)(largeText);
+            expect(tokens).toBe(Math.ceil(10000 / 3.5));
+        });
+    });
+    describe('calculateSafeItemLimit', () => {
+        const createTestItems = (count, size) => {
+            const content = {
+                small: 'Small content',
+                medium: 'Medium content that is longer and has more details'.repeat(5),
+                large: 'Large content with substantial information'.repeat(20),
+            };
+            return Array.from({ length: count }, (_, i) => ({
+                key: `item_${i}`,
+                value: content[size],
+                category: 'test',
+                priority: 'normal',
+                channel: 'test',
+                created_at: '2024-01-20T10:00:00Z',
+                updated_at: '2024-01-20T10:00:00Z',
+            }));
+        };
+        it('should calculate safe limit for small items', () => {
+            const items = createTestItems(100, 'small');
+            const limit = (0, token_limits_1.calculateSafeItemLimit)(items, false);
+            expect(limit).toBeGreaterThan(0);
+            expect(limit).toBeLessThanOrEqual(100);
+        });
+        it('should calculate smaller limit for large items', () => {
+            const smallItems = createTestItems(100, 'small');
+            const largeItems = createTestItems(100, 'large');
+            const smallLimit = (0, token_limits_1.calculateSafeItemLimit)(smallItems, false);
+            const largeLimit = (0, token_limits_1.calculateSafeItemLimit)(largeItems, false);
+            expect(largeLimit).toBeLessThan(smallLimit);
+        });
+        it('should calculate smaller limit with metadata', () => {
+            // Create items with actual metadata that would be added
+            const items = createTestItems(100, 'medium').map(item => ({
+                ...item,
+                metadata: JSON.stringify({
+                    tags: ['test', 'example'],
+                    timestamp: new Date().toISOString(),
+                    additionalInfo: 'Extra metadata that adds size',
+                }),
+                size: 500,
+            }));
+            const withoutMetadataLimit = (0, token_limits_1.calculateSafeItemLimit)(items, false);
+            const withMetadataLimit = (0, token_limits_1.calculateSafeItemLimit)(items, true);
+            // When metadata is included, each item becomes larger due to additional fields
+            // This should result in fewer items fitting in the token limit
+            // If they're equal, it might mean both hit the maxItems constraint
+            expect(withMetadataLimit).toBeLessThanOrEqual(withoutMetadataLimit);
+        });
+        it('should respect min and max constraints', () => {
+            const items = createTestItems(1000, 'small');
+            const config = {
+                ...token_limits_1.DEFAULT_TOKEN_CONFIG,
+                minItems: 5,
+                maxItems: 50,
+            };
+            const limit = (0, token_limits_1.calculateSafeItemLimit)(items, false, config);
+            expect(limit).toBeGreaterThanOrEqual(5);
+            expect(limit).toBeLessThanOrEqual(50);
+        });
+        it('should return 0 for empty array', () => {
+            const limit = (0, token_limits_1.calculateSafeItemLimit)([], false);
+            expect(limit).toBe(0);
+        });
+    });
+    describe('checkTokenLimit', () => {
+        const createLargeDataset = () => {
+            return Array.from({ length: 200 }, (_, i) => ({
+                key: `item_${i}`,
+                value: `Large content that would cause token overflow when many items are combined. `.repeat(10),
+                category: 'test',
+                priority: 'high',
+                metadata: JSON.stringify({ index: i }),
+                created_at: '2024-01-20T10:00:00Z',
+                updated_at: '2024-01-20T10:00:00Z',
+            }));
+        };
+        it('should detect when token limit is exceeded', () => {
+            const items = createLargeDataset();
+            const { exceedsLimit, estimatedTokens, safeItemCount } = (0, token_limits_1.checkTokenLimit)(items, true);
+            expect(exceedsLimit).toBe(true);
+            expect(estimatedTokens).toBeGreaterThan(token_limits_1.DEFAULT_TOKEN_CONFIG.mcpMaxTokens * token_limits_1.DEFAULT_TOKEN_CONFIG.safetyBuffer);
+            expect(safeItemCount).toBeLessThan(items.length);
+        });
+        it('should not exceed limit for small datasets', () => {
+            const items = Array.from({ length: 10 }, (_, i) => ({
+                key: `item_${i}`,
+                value: 'Small content',
+                category: 'test',
+            }));
+            const { exceedsLimit, estimatedTokens } = (0, token_limits_1.checkTokenLimit)(items, false);
+            expect(exceedsLimit).toBe(false);
+            expect(estimatedTokens).toBeLessThan(token_limits_1.DEFAULT_TOKEN_CONFIG.mcpMaxTokens * token_limits_1.DEFAULT_TOKEN_CONFIG.safetyBuffer);
+        });
+        it('should handle metadata transformation', () => {
+            const items = [
+                {
+                    key: 'test',
+                    value: 'content',
+                    metadata: '{"tag": "test"}', // String metadata
+                },
+            ];
+            const { exceedsLimit } = (0, token_limits_1.checkTokenLimit)(items, true);
+            expect(exceedsLimit).toBe(false);
+        });
+        it('should handle invalid JSON in metadata gracefully', () => {
+            const items = [
+                {
+                    key: 'test1',
+                    value: 'content',
+                    metadata: '{"valid": "json"}',
+                },
+                {
+                    key: 'test2',
+                    value: 'content',
+                    metadata: 'invalid json{', // Invalid JSON
+                },
+                {
+                    key: 'test3',
+                    value: 'content',
+                    metadata: null,
+                },
+            ];
+            // Should not throw, but handle gracefully
+            expect(() => {
+                const { exceedsLimit, estimatedTokens } = (0, token_limits_1.checkTokenLimit)(items, true);
+                expect(exceedsLimit).toBe(false);
+                expect(estimatedTokens).toBeGreaterThan(0);
+            }).not.toThrow();
+        });
+    });
+    describe('estimateResponseOverhead', () => {
+        it('should estimate overhead for basic response', () => {
+            const overhead = (0, token_limits_1.estimateResponseOverhead)(10, false);
+            expect(overhead).toBeGreaterThan(0);
+        });
+        it('should estimate higher overhead with metadata', () => {
+            const basicOverhead = (0, token_limits_1.estimateResponseOverhead)(10, false);
+            const metadataOverhead = (0, token_limits_1.estimateResponseOverhead)(10, true);
+            expect(metadataOverhead).toBeGreaterThan(basicOverhead);
+        });
+    });
+    describe('calculateDynamicDefaultLimit', () => {
+        const createMockDb = (items) => ({
+            prepare: jest.fn(() => ({
+                all: jest.fn(() => items),
+            })),
+        });
+        it('should calculate limit based on session data', () => {
+            const sampleItems = Array.from({ length: 10 }, (_, i) => ({
+                key: `item_${i}`,
+                value: 'Sample content for calculation',
+                category: 'test',
+            }));
+            const mockDb = createMockDb(sampleItems);
+            const limit = (0, token_limits_1.calculateDynamicDefaultLimit)('test-session', false, mockDb);
+            expect(limit).toBeGreaterThan(0);
+            expect(limit % 10).toBe(0); // Should be rounded to nearest 10
+        });
+        it('should return conservative defaults for empty session', () => {
+            const mockDb = createMockDb([]);
+            const limitWithMetadata = (0, token_limits_1.calculateDynamicDefaultLimit)('test-session', true, mockDb);
+            const limitWithoutMetadata = (0, token_limits_1.calculateDynamicDefaultLimit)('test-session', false, mockDb);
+            expect(limitWithMetadata).toBe(30);
+            expect(limitWithoutMetadata).toBe(100);
+        });
+        it('should handle database errors gracefully', () => {
+            const mockDb = {
+                prepare: jest.fn(() => {
+                    throw new Error('Database error');
+                }),
+            };
+            const limit = (0, token_limits_1.calculateDynamicDefaultLimit)('test-session', true, mockDb);
+            expect(limit).toBe(30); // Fallback to conservative default
+        });
+        it('should return smaller limit with metadata', () => {
+            // Create items with substantial content that shows clear difference
+            const sampleItems = Array.from({ length: 10 }, (_, i) => ({
+                key: `item_${i}`,
+                value: 'Sample content that is moderately sized'.repeat(20), // Larger content
+                category: 'test',
+                priority: 'high',
+                channel: 'test-channel',
+                metadata: JSON.stringify({
+                    index: i,
+                    tags: ['tag1', 'tag2', 'tag3'],
+                    description: 'Additional metadata that increases size',
+                    timestamp: new Date().toISOString(),
+                }),
+                size: 1000,
+                created_at: '2024-01-20T10:00:00Z',
+                updated_at: '2024-01-20T10:00:00Z',
+            }));
+            const mockDb = createMockDb(sampleItems);
+            const withoutMetadata = (0, token_limits_1.calculateDynamicDefaultLimit)('test-session', false, mockDb);
+            const withMetadata = (0, token_limits_1.calculateDynamicDefaultLimit)('test-session', true, mockDb);
+            // Dynamic calculation should return smaller limit when metadata is included
+            // Both should be rounded to nearest 10
+            expect(withMetadata % 10).toBe(0);
+            expect(withoutMetadata % 10).toBe(0);
+            // With larger items and metadata, the difference should be clear
+            // If they're the same, both might be hitting minimum threshold
+            expect(withMetadata).toBeLessThanOrEqual(withoutMetadata);
+        });
+    });
+});

package/dist/__tests__/utils/tool-profiles.test.js

@@ -0,0 +1,374 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+const tool_profiles_1 = require("../../utils/tool-profiles");
+describe('Tool Profiles', () => {
+    describe('ALL_TOOL_NAMES', () => {
+        it('should contain exactly 38 tool names', () => {
+            expect(tool_profiles_1.ALL_TOOL_NAMES).toHaveLength(38);
+        });
+        it('should have no duplicates', () => {
+            const unique = new Set(tool_profiles_1.ALL_TOOL_NAMES);
+            expect(unique.size).toBe(tool_profiles_1.ALL_TOOL_NAMES.length);
+        });
+        it('should all start with "context_"', () => {
+            for (const name of tool_profiles_1.ALL_TOOL_NAMES) {
+                expect(name).toMatch(/^context_/);
+            }
+        });
+    });
+    describe('ALL_TOOL_NAMES_SET', () => {
+        it('should be the same size as ALL_TOOL_NAMES', () => {
+            expect(tool_profiles_1.ALL_TOOL_NAMES_SET.size).toBe(tool_profiles_1.ALL_TOOL_NAMES.length);
+        });
+        it('should contain every entry from ALL_TOOL_NAMES', () => {
+            for (const name of tool_profiles_1.ALL_TOOL_NAMES) {
+                expect(tool_profiles_1.ALL_TOOL_NAMES_SET.has(name)).toBe(true);
+            }
+        });
+    });
+    describe('DEFAULT_PROFILES', () => {
+        it('should define minimal, standard, and full profiles', () => {
+            expect(tool_profiles_1.DEFAULT_PROFILES).toHaveProperty('minimal');
+            expect(tool_profiles_1.DEFAULT_PROFILES).toHaveProperty('standard');
+            expect(tool_profiles_1.DEFAULT_PROFILES).toHaveProperty('full');
+        });
+        it('minimal should have 8 tools', () => {
+            expect(tool_profiles_1.DEFAULT_PROFILES.minimal).toHaveLength(8);
+        });
+        it('standard should have 22 tools', () => {
+            expect(tool_profiles_1.DEFAULT_PROFILES.standard).toHaveLength(22);
+        });
+        it('full should have all 38 tools', () => {
+            expect(tool_profiles_1.DEFAULT_PROFILES.full).toHaveLength(38);
+        });
+        it('minimal should be a subset of standard', () => {
+            const standardSet = new Set(tool_profiles_1.DEFAULT_PROFILES.standard);
+            for (const tool of tool_profiles_1.DEFAULT_PROFILES.minimal) {
+                expect(standardSet.has(tool)).toBe(true);
+            }
+        });
+        it('standard should be a subset of full', () => {
+            const fullSet = new Set(tool_profiles_1.DEFAULT_PROFILES.full);
+            for (const tool of tool_profiles_1.DEFAULT_PROFILES.standard) {
+                expect(fullSet.has(tool)).toBe(true);
+            }
+        });
+        it('all tools in each profile should be valid tool names', () => {
+            for (const [_profileName, tools] of Object.entries(tool_profiles_1.DEFAULT_PROFILES)) {
+                for (const tool of tools) {
+                    expect(tool_profiles_1.ALL_TOOL_NAMES_SET.has(tool)).toBe(true);
+                }
+            }
+        });
+        it('full profile should match ALL_TOOL_NAMES exactly', () => {
+            expect(new Set(tool_profiles_1.DEFAULT_PROFILES.full)).toEqual(new Set(tool_profiles_1.ALL_TOOL_NAMES));
+        });
+    });
+    describe('validateToolNames', () => {
+        it('should return empty array for all valid names', () => {
+            expect((0, tool_profiles_1.validateToolNames)(['context_save', 'context_get'])).toEqual([]);
+        });
+        it('should return unknown names', () => {
+            const result = (0, tool_profiles_1.validateToolNames)(['context_save', 'nonexistent_tool', 'another_fake']);
+            expect(result).toEqual(['nonexistent_tool', 'another_fake']);
+        });
+        it('should handle empty array', () => {
+            expect((0, tool_profiles_1.validateToolNames)([])).toEqual([]);
+        });
+        it('should handle all-invalid array', () => {
+            const result = (0, tool_profiles_1.validateToolNames)(['fake1', 'fake2']);
+            expect(result).toEqual(['fake1', 'fake2']);
+        });
+    });
+    describe('loadConfigFile', () => {
+        const tmpDir = path.join(os.tmpdir(), 'mcp-mk-tool-profiles-test');
+        beforeEach(() => {
+            if (!fs.existsSync(tmpDir)) {
+                fs.mkdirSync(tmpDir, { recursive: true });
+            }
+        });
+        afterEach(() => {
+            if (fs.existsSync(tmpDir)) {
+                fs.rmSync(tmpDir, { recursive: true, force: true });
+            }
+        });
+        it('should return null when config file does not exist', () => {
+            const result = (0, tool_profiles_1.loadConfigFile)(path.join(tmpDir, 'nonexistent.json'));
+            expect(result).toBeNull();
+        });
+        it('should parse valid config file', () => {
+            const configPath = path.join(tmpDir, 'config.json');
+            fs.writeFileSync(configPath, JSON.stringify({
+                profiles: {
+                    minimal: ['context_save', 'context_get'],
+                },
+            }));
+            const result = (0, tool_profiles_1.loadConfigFile)(configPath);
+            expect(result).not.toBeNull();
+            expect(result.profiles.minimal).toEqual(['context_save', 'context_get']);
+        });
+        it('should return null and warn on JSON syntax error', () => {
+            const configPath = path.join(tmpDir, 'bad.json');
+            fs.writeFileSync(configPath, '{ invalid json }');
+            const warnSpy = jest.spyOn(console, 'warn').mockImplementation();
+            const result = (0, tool_profiles_1.loadConfigFile)(configPath);
+            expect(result).toBeNull();
+            expect(warnSpy).toHaveBeenCalledWith(expect.stringContaining('Failed to load config file'));
+            warnSpy.mockRestore();
+        });
+        it('should return null and warn on missing profiles key', () => {
+            const configPath = path.join(tmpDir, 'no-profiles.json');
+            fs.writeFileSync(configPath, JSON.stringify({ something: 'else' }));
+            const warnSpy = jest.spyOn(console, 'warn').mockImplementation();
+            const result = (0, tool_profiles_1.loadConfigFile)(configPath);
+            expect(result).toBeNull();
+            expect(warnSpy).toHaveBeenCalledWith(expect.stringContaining('missing a valid "profiles" key'));
+            warnSpy.mockRestore();
+        });
+        it('should handle config file with extra keys gracefully', () => {
+            const configPath = path.join(tmpDir, 'extra.json');
+            fs.writeFileSync(configPath, JSON.stringify({
+                profiles: { custom: ['context_save'] },
+                extraKey: 'ignored',
+            }));
+            const result = (0, tool_profiles_1.loadConfigFile)(configPath);
+            expect(result).not.toBeNull();
+            expect(result.profiles.custom).toEqual(['context_save']);
+        });
+        it('should return null when profiles is an array instead of object', () => {
+            const configPath = path.join(tmpDir, 'array-profiles.json');
+            fs.writeFileSync(configPath, JSON.stringify({ profiles: ['context_save'] }));
+            const warnSpy = jest.spyOn(console, 'warn').mockImplementation();
+            const result = (0, tool_profiles_1.loadConfigFile)(configPath);
+            expect(result).toBeNull();
+            expect(warnSpy).toHaveBeenCalledWith(expect.stringContaining('missing a valid "profiles" key'));
+            warnSpy.mockRestore();
+        });
+        it('should return null when profiles is null', () => {
+            const configPath = path.join(tmpDir, 'null-profiles.json');
+            fs.writeFileSync(configPath, JSON.stringify({ profiles: null }));
+            const warnSpy = jest.spyOn(console, 'warn').mockImplementation();
+            const result = (0, tool_profiles_1.loadConfigFile)(configPath);
+            expect(result).toBeNull();
+            warnSpy.mockRestore();
+        });
+        it('should return null when root is an array', () => {
+            const configPath = path.join(tmpDir, 'root-array.json');
+            fs.writeFileSync(configPath, JSON.stringify([{ profiles: {} }]));
+            const warnSpy = jest.spyOn(console, 'warn').mockImplementation();
+            const result = (0, tool_profiles_1.loadConfigFile)(configPath);
+            expect(result).toBeNull();
+            warnSpy.mockRestore();
+        });
+    });
+    describe('resolveActiveProfile', () => {
+        const originalEnv = process.env.TOOL_PROFILE;
+        const tmpDir = path.join(os.tmpdir(), 'mcp-mk-resolve-profile-test');
+        beforeEach(() => {
+            delete process.env.TOOL_PROFILE;
+            if (!fs.existsSync(tmpDir)) {
+                fs.mkdirSync(tmpDir, { recursive: true });
+            }
+        });
+        afterEach(() => {
+            if (originalEnv !== undefined) {
+                process.env.TOOL_PROFILE = originalEnv;
+            }
+            else {
+                delete process.env.TOOL_PROFILE;
+            }
+            if (fs.existsSync(tmpDir)) {
+                fs.rmSync(tmpDir, { recursive: true, force: true });
+            }
+        });
+        it('should default to full when no env var and no config', () => {
+            const configPath = path.join(tmpDir, 'nonexistent.json');
+            const result = (0, tool_profiles_1.resolveActiveProfile)(configPath);
+            expect(result.profileName).toBe('full');
+            expect(result.tools.size).toBe(38);
+            expect(result.source).toBe('default');
+            expect(result.warnings).toHaveLength(0);
+        });
+        it('should use env var profile from built-in defaults', () => {
+            process.env.TOOL_PROFILE = 'minimal';
+            const configPath = path.join(tmpDir, 'nonexistent.json');
+            const result = (0, tool_profiles_1.resolveActiveProfile)(configPath);
+            expect(result.profileName).toBe('minimal');
+            expect(result.tools.size).toBe(8);
+            expect(result.source).toBe('env+builtin');
+        });
+        it('should use env var profile from config file (takes precedence)', () => {
+            process.env.TOOL_PROFILE = 'minimal';
+            const configPath = path.join(tmpDir, 'config.json');
+            // Config overrides minimal to have only 2 tools
+            fs.writeFileSync(configPath, JSON.stringify({
+                profiles: { minimal: ['context_save', 'context_get'] },
+            }));
+            const result = (0, tool_profiles_1.resolveActiveProfile)(configPath);
+            expect(result.profileName).toBe('minimal');
+            expect(result.tools.size).toBe(2);
+            expect(result.source).toBe('env+config');
+        });
+        it('should warn and fallback to full on invalid profile name', () => {
+            process.env.TOOL_PROFILE = 'nonexistent_profile';
+            const configPath = path.join(tmpDir, 'nonexistent.json');
+            const result = (0, tool_profiles_1.resolveActiveProfile)(configPath);
+            expect(result.profileName).toBe('full');
+            expect(result.tools.size).toBe(38);
+            expect(result.source).toBe('default');
+            expect(result.warnings.length).toBeGreaterThan(0);
+            expect(result.warnings[0]).toContain('Unknown TOOL_PROFILE');
+        });
+        it('should warn on unknown tool names in profile', () => {
+            const configPath = path.join(tmpDir, 'config.json');
+            fs.writeFileSync(configPath, JSON.stringify({
+                profiles: { custom: ['context_save', 'fake_tool'] },
+            }));
+            process.env.TOOL_PROFILE = 'custom';
+            const result = (0, tool_profiles_1.resolveActiveProfile)(configPath);
+            expect(result.tools.size).toBe(1);
+            expect(result.tools.has('context_save')).toBe(true);
+            expect(result.warnings.length).toBeGreaterThan(0);
+            expect(result.warnings[0]).toContain('fake_tool');
+        });
+        it('should fallback to full when profile resolves to empty', () => {
+            const configPath = path.join(tmpDir, 'config.json');
+            fs.writeFileSync(configPath, JSON.stringify({
+                profiles: { empty: ['fake_tool_1', 'fake_tool_2'] },
+            }));
+            process.env.TOOL_PROFILE = 'empty';
+            const result = (0, tool_profiles_1.resolveActiveProfile)(configPath);
+            expect(result.profileName).toBe('full');
+            expect(result.tools.size).toBe(38);
+            expect(result.warnings.some(w => w.includes('no valid tools'))).toBe(true);
+        });
+        it('should trim whitespace from TOOL_PROFILE env var', () => {
+            process.env.TOOL_PROFILE = '  minimal  ';
+            const configPath = path.join(tmpDir, 'nonexistent.json');
+            const result = (0, tool_profiles_1.resolveActiveProfile)(configPath);
+            expect(result.profileName).toBe('minimal');
+            expect(result.tools.size).toBe(8);
+        });
+        it('should support custom profiles from config file', () => {
+            const configPath = path.join(tmpDir, 'config.json');
+            fs.writeFileSync(configPath, JSON.stringify({
+                profiles: {
+                    my_workflow: ['context_save', 'context_get', 'context_diff'],
+                },
+            }));
+            process.env.TOOL_PROFILE = 'my_workflow';
+            const result = (0, tool_profiles_1.resolveActiveProfile)(configPath);
+            expect(result.profileName).toBe('my_workflow');
+            expect(result.tools.size).toBe(3);
+            expect(result.source).toBe('env+config');
+        });
+        it('should use standard profile from env var', () => {
+            process.env.TOOL_PROFILE = 'standard';
+            const configPath = path.join(tmpDir, 'nonexistent.json');
+            const result = (0, tool_profiles_1.resolveActiveProfile)(configPath);
+            expect(result.profileName).toBe('standard');
+            expect(result.tools.size).toBe(22);
+            expect(result.source).toBe('env+builtin');
+        });
+        it('should treat empty string TOOL_PROFILE as unset', () => {
+            process.env.TOOL_PROFILE = '';
+            const configPath = path.join(tmpDir, 'nonexistent.json');
+            const result = (0, tool_profiles_1.resolveActiveProfile)(configPath);
+            expect(result.profileName).toBe('full');
+            expect(result.tools.size).toBe(38);
+            expect(result.source).toBe('default');
+        });
+        it('should handle config profile with null value gracefully', () => {
+            const configPath = path.join(tmpDir, 'config.json');
+            fs.writeFileSync(configPath, JSON.stringify({ profiles: { broken: null } }));
+            process.env.TOOL_PROFILE = 'broken';
+            const warnSpy = jest.spyOn(console, 'warn').mockImplementation();
+            const result = (0, tool_profiles_1.resolveActiveProfile)(configPath);
+            // 'broken' not in built-ins, so falls through to unknown profile fallback
+            expect(result.profileName).toBe('full');
+            expect(result.tools.size).toBe(38);
+            expect(result.warnings.some(w => w.includes('not a valid array of strings'))).toBe(true);
+            warnSpy.mockRestore();
+        });
+        it('should handle config profile with non-array value gracefully', () => {
+            const configPath = path.join(tmpDir, 'config.json');
+            fs.writeFileSync(configPath, JSON.stringify({ profiles: { broken: 'not-an-array' } }));
+            process.env.TOOL_PROFILE = 'broken';
+            const warnSpy = jest.spyOn(console, 'warn').mockImplementation();
+            const result = (0, tool_profiles_1.resolveActiveProfile)(configPath);
+            expect(result.profileName).toBe('full');
+            expect(result.tools.size).toBe(38);
+            expect(result.warnings.some(w => w.includes('not a valid array of strings'))).toBe(true);
+            warnSpy.mockRestore();
+        });
+        it('should handle config profile with non-string array elements gracefully', () => {
+            const configPath = path.join(tmpDir, 'config.json');
+            fs.writeFileSync(configPath, JSON.stringify({ profiles: { broken: [1, null, true] } }));
+            process.env.TOOL_PROFILE = 'broken';
+            const warnSpy = jest.spyOn(console, 'warn').mockImplementation();
+            const result = (0, tool_profiles_1.resolveActiveProfile)(configPath);
+            expect(result.profileName).toBe('full');
+            expect(result.tools.size).toBe(38);
+            expect(result.warnings.some(w => w.includes('not a valid array of strings'))).toBe(true);
+            warnSpy.mockRestore();
+        });
+        it('should fall back to built-in when config profile for known name is invalid', () => {
+            const configPath = path.join(tmpDir, 'config.json');
+            // Config has invalid 'minimal' entry, but built-in 'minimal' exists
+            fs.writeFileSync(configPath, JSON.stringify({ profiles: { minimal: 42 } }));
+            process.env.TOOL_PROFILE = 'minimal';
+            const warnSpy = jest.spyOn(console, 'warn').mockImplementation();
+            const result = (0, tool_profiles_1.resolveActiveProfile)(configPath);
+            expect(result.profileName).toBe('minimal');
+            expect(result.tools.size).toBe(8);
+            expect(result.source).toBe('env+builtin');
+            expect(result.warnings.some(w => w.includes('not a valid array of strings'))).toBe(true);
+            warnSpy.mockRestore();
+        });
+        it('should deduplicate tool names in profile via Set', () => {
+            const configPath = path.join(tmpDir, 'config.json');
+            fs.writeFileSync(configPath, JSON.stringify({
+                profiles: { dupes: ['context_save', 'context_save', 'context_get'] },
+            }));
+            process.env.TOOL_PROFILE = 'dupes';
+            const result = (0, tool_profiles_1.resolveActiveProfile)(configPath);
+            expect(result.tools.size).toBe(2);
+        });
+    });
+});