@inkeep/agents-cli 0.1.0

package/dist/__tests__/commands/push.test.js

@@ -0,0 +1,265 @@
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import { pushCommand } from '../../commands/push.js';
+import * as core from '@inkeep/agents-core';
+import inquirer from 'inquirer';
+import { existsSync } from 'node:fs';
+// Mock all external dependencies
+vi.mock('node:fs');
+vi.mock('@inkeep/agents-core');
+vi.mock('inquirer');
+vi.mock('chalk', () => ({
+    default: {
+        red: vi.fn((text) => text),
+        yellow: vi.fn((text) => text),
+        green: vi.fn((text) => text),
+        cyan: vi.fn((text) => text),
+        gray: vi.fn((text) => text),
+    },
+}));
+vi.mock('ora', () => ({
+    default: vi.fn(() => ({
+        start: vi.fn().mockReturnThis(),
+        succeed: vi.fn().mockReturnThis(),
+        fail: vi.fn().mockReturnThis(),
+        warn: vi.fn().mockReturnThis(),
+        stop: vi.fn().mockReturnThis(),
+        text: '',
+    })),
+}));
+vi.mock('../../api.js', () => ({
+    ApiClient: {
+        create: vi.fn().mockResolvedValue({}),
+    },
+}));
+vi.mock('../../config.js', () => ({
+    validateConfiguration: vi.fn().mockResolvedValue({
+        tenantId: 'test-tenant',
+        projectId: 'test-project',
+        apiUrl: 'http://localhost:3002',
+        sources: {
+            tenantId: 'config',
+            projectId: 'config',
+            apiUrl: 'config',
+        },
+    }),
+}));
+describe('Push Command - Project Validation', () => {
+    let mockDbClient;
+    let mockGetProject;
+    let mockCreateProject;
+    let mockExit;
+    let mockLog;
+    beforeEach(() => {
+        vi.clearAllMocks();
+        // Setup database client mock
+        mockDbClient = {};
+        mockGetProject = vi.fn();
+        mockCreateProject = vi.fn();
+        core.createDatabaseClient.mockReturnValue(mockDbClient);
+        core.getProject.mockReturnValue(mockGetProject);
+        core.createProject.mockReturnValue(mockCreateProject);
+        // Mock process.exit to prevent test runner from exiting
+        mockExit = vi.fn();
+        vi.spyOn(process, 'exit').mockImplementation(mockExit);
+        // Mock console methods
+        mockLog = vi.fn();
+        vi.spyOn(console, 'log').mockImplementation(mockLog);
+        vi.spyOn(console, 'error').mockImplementation(vi.fn());
+        // Mock file existence check for graph file
+        existsSync.mockReturnValue(true);
+        // Default environment
+        process.env.DB_FILE_NAME = 'test.db';
+    });
+    it('should validate project exists before pushing graph', async () => {
+        // Mock project exists
+        mockGetProject.mockResolvedValue({
+            id: 'test-project',
+            name: 'Test Project',
+            tenantId: 'test-tenant',
+        });
+        // Mock graph file import
+        const mockGraph = {
+            init: vi.fn().mockResolvedValue(undefined),
+            getId: vi.fn().mockReturnValue('test-graph'),
+            getName: vi.fn().mockReturnValue('Test Graph'),
+            getAgents: vi.fn().mockReturnValue([]),
+            getStats: vi.fn().mockReturnValue({
+                agentCount: 1,
+                toolCount: 0,
+                relationCount: 0,
+            }),
+            getDefaultAgent: vi.fn().mockReturnValue(null),
+            setConfig: vi.fn(),
+        };
+        vi.doMock('/test/path/graph.js', () => ({
+            default: mockGraph,
+        }));
+        // Run in TypeScript mode (skip tsx spawn)
+        process.env.TSX_RUNNING = '1';
+        await pushCommand('/test/path/graph.js', {});
+        // Verify project validation was called
+        expect(mockGetProject).toHaveBeenCalledWith({
+            scopes: { tenantId: 'test-tenant', projectId: 'test-project' },
+        });
+    });
+    it('should prompt to create project when it does not exist', async () => {
+        // Mock project doesn't exist
+        mockGetProject.mockResolvedValue(null);
+        // Mock user confirms project creation
+        inquirer.prompt
+            .mockResolvedValueOnce({ shouldCreate: true })
+            .mockResolvedValueOnce({
+            projectName: 'New Project',
+            projectDescription: 'Test description',
+        });
+        // Mock project creation success
+        mockCreateProject.mockResolvedValue({
+            id: 'test-project',
+            name: 'New Project',
+            description: 'Test description',
+            tenantId: 'test-tenant',
+        });
+        // Mock graph file import
+        const mockGraph = {
+            init: vi.fn().mockResolvedValue(undefined),
+            getId: vi.fn().mockReturnValue('test-graph'),
+            getName: vi.fn().mockReturnValue('Test Graph'),
+            getAgents: vi.fn().mockReturnValue([]),
+            getStats: vi.fn().mockReturnValue({
+                agentCount: 1,
+                toolCount: 0,
+                relationCount: 0,
+            }),
+            getDefaultAgent: vi.fn().mockReturnValue(null),
+            setConfig: vi.fn(),
+        };
+        vi.doMock('/test/path/graph.js', () => ({
+            default: mockGraph,
+        }));
+        process.env.TSX_RUNNING = '1';
+        await pushCommand('/test/path/graph.js', {});
+        // Verify project creation was prompted
+        expect(inquirer.prompt).toHaveBeenCalledWith(expect.arrayContaining([
+            expect.objectContaining({
+                type: 'confirm',
+                name: 'shouldCreate',
+                message: expect.stringContaining('does not exist'),
+            }),
+        ]));
+        // Verify project was created
+        expect(mockCreateProject).toHaveBeenCalledWith({
+            id: 'test-project',
+            tenantId: 'test-tenant',
+            name: 'New Project',
+            description: 'Test description',
+        });
+    });
+    it('should exit if user declines to create missing project', async () => {
+        // Mock project doesn't exist
+        mockGetProject.mockResolvedValue(null);
+        // Mock user declines project creation
+        inquirer.prompt.mockResolvedValueOnce({ shouldCreate: false });
+        // Mock graph file import (needed to prevent errors)
+        const mockGraph = {
+            init: vi.fn().mockResolvedValue(undefined),
+            getId: vi.fn().mockReturnValue('test-graph'),
+            getName: vi.fn().mockReturnValue('Test Graph'),
+            getAgents: vi.fn().mockReturnValue([]),
+            getStats: vi.fn().mockReturnValue({
+                agentCount: 1,
+                toolCount: 0,
+                relationCount: 0,
+            }),
+            getDefaultAgent: vi.fn().mockReturnValue(null),
+            setConfig: vi.fn(),
+        };
+        vi.doMock('/test/path/graph.js', () => ({
+            default: mockGraph,
+        }));
+        process.env.TSX_RUNNING = '1';
+        await pushCommand('/test/path/graph.js', {});
+        // Verify push was cancelled
+        expect(mockExit).toHaveBeenCalledWith(0);
+        expect(mockLog).toHaveBeenCalledWith(expect.stringContaining('Push cancelled'));
+        // Verify project was not created
+        expect(mockCreateProject).not.toHaveBeenCalled();
+    });
+    it('should handle project creation errors gracefully', async () => {
+        // Mock project doesn't exist
+        mockGetProject.mockResolvedValue(null);
+        // Mock user confirms project creation
+        inquirer.prompt
+            .mockResolvedValueOnce({ shouldCreate: true })
+            .mockResolvedValueOnce({
+            projectName: 'New Project',
+            projectDescription: '',
+        });
+        // Mock project creation failure
+        mockCreateProject.mockRejectedValue(new Error('Database error'));
+        process.env.TSX_RUNNING = '1';
+        await pushCommand('/test/path/graph.js', {});
+        // Verify error handling
+        expect(mockExit).toHaveBeenCalledWith(1);
+        expect(console.error).toHaveBeenCalledWith(expect.stringContaining('Error'), 'Database error');
+    });
+    it('should use DB_FILE_NAME environment variable for database location', async () => {
+        process.env.DB_FILE_NAME = 'custom-location.db';
+        mockGetProject.mockResolvedValue({
+            id: 'test-project',
+            name: 'Test Project',
+            tenantId: 'test-tenant',
+        });
+        const mockGraph = {
+            init: vi.fn().mockResolvedValue(undefined),
+            getId: vi.fn().mockReturnValue('test-graph'),
+            getName: vi.fn().mockReturnValue('Test Graph'),
+            getAgents: vi.fn().mockReturnValue([]),
+            getStats: vi.fn().mockReturnValue({
+                agentCount: 1,
+                toolCount: 0,
+                relationCount: 0,
+            }),
+            getDefaultAgent: vi.fn().mockReturnValue(null),
+            setConfig: vi.fn(),
+        };
+        vi.doMock('/test/path/graph.js', () => ({
+            default: mockGraph,
+        }));
+        process.env.TSX_RUNNING = '1';
+        await pushCommand('/test/path/graph.js', {});
+        // Verify correct database URL was used
+        expect(core.createDatabaseClient).toHaveBeenCalledWith({
+            url: expect.stringContaining('custom-location.db'),
+        });
+    });
+    it('should default to local.db when DB_FILE_NAME is not set', async () => {
+        delete process.env.DB_FILE_NAME;
+        mockGetProject.mockResolvedValue({
+            id: 'test-project',
+            name: 'Test Project',
+            tenantId: 'test-tenant',
+        });
+        const mockGraph = {
+            init: vi.fn().mockResolvedValue(undefined),
+            getId: vi.fn().mockReturnValue('test-graph'),
+            getName: vi.fn().mockReturnValue('Test Graph'),
+            getAgents: vi.fn().mockReturnValue([]),
+            getStats: vi.fn().mockReturnValue({
+                agentCount: 1,
+                toolCount: 0,
+                relationCount: 0,
+            }),
+            getDefaultAgent: vi.fn().mockReturnValue(null),
+            setConfig: vi.fn(),
+        };
+        vi.doMock('/test/path/graph.js', () => ({
+            default: mockGraph,
+        }));
+        process.env.TSX_RUNNING = '1';
+        await pushCommand('/test/path/graph.js', {});
+        // Verify default database URL was used
+        expect(core.createDatabaseClient).toHaveBeenCalledWith({
+            url: expect.stringContaining('local.db'),
+        });
+    });
+});

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

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,106 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { validateConfiguration } from '../config.js';
+// Save original env and cwd
+const originalEnv = process.env;
+const originalCwd = process.cwd();
+// Mock the file system to prevent finding actual config files
+vi.mock('node:fs', () => ({
+    existsSync: vi.fn(() => false),
+}));
+// Mock process.cwd to avoid loading the actual config file
+vi.mock('node:process', () => ({
+    cwd: () => '/tmp/test-cli',
+}));
+describe('Configuration Validation', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+        process.env = { ...originalEnv };
+        delete process.env.INKEEP_TENANT_ID;
+        delete process.env.INKEEP_API_URL;
+        delete process.env.INKEEP_MANAGEMENT_API_URL;
+        delete process.env.INKEEP_EXECUTION_API_URL;
+    });
+    afterEach(() => {
+        process.env = originalEnv;
+        vi.restoreAllMocks();
+    });
+    describe('validateConfiguration', () => {
+        describe('Valid Configurations', () => {
+            it('should accept --tenant-id with --management-api-url and --execution-api-url flags', async () => {
+                const config = await validateConfiguration('test-tenant', 'http://localhost:3002', 'http://localhost:3003', undefined);
+                expect(config.tenantId).toBe('test-tenant');
+                expect(config.managementApiUrl).toBe('http://localhost:3002');
+                expect(config.executionApiUrl).toBe('http://localhost:3003');
+                expect(config.sources.tenantId).toBe('command-line flag (--tenant-id)');
+                expect(config.sources.managementApiUrl).toBe('command-line flag (--management-api-url)');
+                expect(config.sources.executionApiUrl).toBe('command-line flag (--execution-api-url)');
+            });
+            it('should use environment variables when no flags provided', async () => {
+                process.env.INKEEP_TENANT_ID = 'env-tenant';
+                process.env.INKEEP_MANAGEMENT_API_URL = 'http://localhost:9090';
+                process.env.INKEEP_EXECUTION_API_URL = 'http://localhost:9091';
+                const config = await validateConfiguration(undefined, undefined, undefined, undefined);
+                expect(config.tenantId).toBe('env-tenant');
+                expect(config.managementApiUrl).toBe('http://localhost:9090');
+                expect(config.executionApiUrl).toBe('http://localhost:9091');
+                expect(config.sources.tenantId).toBe('environment variable (INKEEP_TENANT_ID)');
+                expect(config.sources.managementApiUrl).toBe('environment variable (INKEEP_MANAGEMENT_API_URL)');
+                expect(config.sources.executionApiUrl).toBe('environment variable (INKEEP_EXECUTION_API_URL)');
+            });
+            it('should allow command-line flags to override environment variables', async () => {
+                process.env.INKEEP_TENANT_ID = 'env-tenant';
+                process.env.INKEEP_MANAGEMENT_API_URL = 'http://localhost:9090';
+                process.env.INKEEP_EXECUTION_API_URL = 'http://localhost:9091';
+                const config = await validateConfiguration('cli-tenant', 'http://cli-management', 'http://cli-execution', undefined);
+                expect(config.tenantId).toBe('cli-tenant');
+                expect(config.managementApiUrl).toBe('http://cli-management');
+                expect(config.executionApiUrl).toBe('http://cli-execution');
+                expect(config.sources.tenantId).toBe('command-line flag (--tenant-id)');
+                expect(config.sources.managementApiUrl).toBe('command-line flag (--management-api-url)');
+                expect(config.sources.executionApiUrl).toBe('command-line flag (--execution-api-url)');
+            });
+        });
+        describe('Invalid Configurations', () => {
+            it('should reject --config-file-path with --tenant-id', async () => {
+                await expect(validateConfiguration('test-tenant', undefined, undefined, '/path/to/config.js')).rejects.toThrow('Invalid configuration combination');
+            });
+            it('should reject --tenant-id without both API URLs', async () => {
+                await expect(validateConfiguration('test-tenant', undefined, undefined, undefined)).rejects.toThrow('--tenant-id requires --management-api-url and --execution-api-url');
+            });
+            it('should reject when no configuration is provided', async () => {
+                await expect(validateConfiguration(undefined, undefined, undefined, undefined)).rejects.toThrow('No configuration found');
+            });
+        });
+        describe('Configuration Source Tracking', () => {
+            it('should correctly identify command-line flag sources', async () => {
+                const config = await validateConfiguration('cli-tenant', 'http://cli-management', 'http://cli-execution', undefined);
+                expect(config.sources.tenantId).toBe('command-line flag (--tenant-id)');
+                expect(config.sources.managementApiUrl).toBe('command-line flag (--management-api-url)');
+                expect(config.sources.executionApiUrl).toBe('command-line flag (--execution-api-url)');
+                expect(config.sources.configFile).toBeUndefined();
+            });
+            it('should correctly identify environment variable sources', async () => {
+                process.env.INKEEP_TENANT_ID = 'env-tenant';
+                process.env.INKEEP_MANAGEMENT_API_URL = 'http://env-management';
+                process.env.INKEEP_EXECUTION_API_URL = 'http://env-execution';
+                const config = await validateConfiguration(undefined, undefined, undefined, undefined);
+                expect(config.sources.tenantId).toBe('environment variable (INKEEP_TENANT_ID)');
+                expect(config.sources.managementApiUrl).toBe('environment variable (INKEEP_MANAGEMENT_API_URL)');
+                expect(config.sources.executionApiUrl).toBe('environment variable (INKEEP_EXECUTION_API_URL)');
+            });
+            it('should correctly identify mixed sources with env and flag', async () => {
+                process.env.INKEEP_TENANT_ID = 'env-tenant';
+                process.env.INKEEP_MANAGEMENT_API_URL = 'http://env-management';
+                process.env.INKEEP_EXECUTION_API_URL = 'http://env-execution';
+                // Override only the management API URL with a flag
+                const config = await validateConfiguration(undefined, 'http://override-management', undefined, undefined);
+                expect(config.tenantId).toBe('env-tenant');
+                expect(config.managementApiUrl).toBe('http://override-management');
+                expect(config.executionApiUrl).toBe('http://env-execution');
+                expect(config.sources.tenantId).toBe('environment variable (INKEEP_TENANT_ID)');
+                expect(config.sources.managementApiUrl).toBe('command-line flag (--management-api-url)');
+                expect(config.sources.executionApiUrl).toBe('environment variable (INKEEP_EXECUTION_API_URL)');
+            });
+        });
+    });
+});

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

@@ -0,0 +1 @@
+export {};

package/dist/__tests__/package.test.js

@@ -0,0 +1,82 @@
+import { readFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { beforeEach, describe, expect, it } from 'vitest';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+describe('Package Configuration', () => {
+    const packageJsonPath = join(__dirname, '..', '..', 'package.json');
+    const tsConfigTypeCheckPath = join(__dirname, '..', '..', 'tsconfig.typecheck.json');
+    let packageJson;
+    let tsConfigTypeCheck;
+    beforeEach(() => {
+        const packageJsonContent = readFileSync(packageJsonPath, 'utf-8');
+        packageJson = JSON.parse(packageJsonContent);
+        const tsConfigTypeCheckContent = readFileSync(tsConfigTypeCheckPath, 'utf-8');
+        tsConfigTypeCheck = JSON.parse(tsConfigTypeCheckContent);
+    });
+    describe('package.json', () => {
+        it('should have correct package name', () => {
+            expect(packageJson.name).toBe('@inkeep/agents-cli');
+        });
+        it('should have a valid version', () => {
+            expect(packageJson.version).toMatch(/^\d+\.\d+\.\d+$/);
+        });
+        it('should have correct bin configuration', () => {
+            expect(packageJson.bin).toEqual({
+                inkeep: './dist/index.js',
+            });
+        });
+        it('should have correct main entry point', () => {
+            expect(packageJson.main).toBe('./dist/exports.js');
+        });
+        it('should be set to module type', () => {
+            expect(packageJson.type).toBe('module');
+        });
+        it('should have required dependencies', () => {
+            expect(packageJson.dependencies).toHaveProperty('commander');
+            expect(packageJson.dependencies).toHaveProperty('chalk');
+        });
+        it('should have required dev dependencies', () => {
+            expect(packageJson.devDependencies).toHaveProperty('typescript');
+            expect(packageJson.devDependencies).toHaveProperty('vitest');
+            expect(packageJson.devDependencies).toHaveProperty('@types/node');
+        });
+        it('should have test scripts', () => {
+            expect(packageJson.scripts).toHaveProperty('test');
+            expect(packageJson.scripts).toHaveProperty('test:watch');
+            expect(packageJson.scripts).toHaveProperty('test:coverage');
+        });
+        it('should have typecheck script', () => {
+            expect(packageJson.scripts).toHaveProperty('typecheck');
+            expect(packageJson.scripts.typecheck).toBe('tsc --noEmit --project tsconfig.typecheck.json');
+        });
+        it('should have correct Node.js engine requirement', () => {
+            expect(packageJson.engines.node).toBe('>=20.x');
+        });
+        it('should have correct author', () => {
+            expect(packageJson.author).toBe('Inkeep <support@inkeep.com>');
+        });
+        it('should have correct license reference', () => {
+            expect(packageJson.license).toBe('SEE LICENSE IN LICENSE.md');
+        });
+    });
+    describe('tsconfig.typecheck.json', () => {
+        it('should extend base tsconfig', () => {
+            expect(tsConfigTypeCheck.extends).toBe('./tsconfig.json');
+        });
+        it('should have correct compiler options', () => {
+            expect(tsConfigTypeCheck.compilerOptions).toHaveProperty('noEmit', true);
+            expect(tsConfigTypeCheck.compilerOptions).toHaveProperty('skipLibCheck', true);
+        });
+        it('should include src files', () => {
+            expect(tsConfigTypeCheck.include).toContain('src/**/*');
+        });
+        it('should exclude test files and build artifacts', () => {
+            expect(tsConfigTypeCheck.exclude).toContain('node_modules');
+            expect(tsConfigTypeCheck.exclude).toContain('dist');
+            expect(tsConfigTypeCheck.exclude).toContain('**/*.test.ts');
+            expect(tsConfigTypeCheck.exclude).toContain('src/__tests__/**/*');
+        });
+    });
+});

package/dist/__tests__/utils/json-comparator.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/__tests__/utils/json-comparator.test.js

@@ -0,0 +1,174 @@
+import { describe, expect, it } from 'vitest';
+import { compareJsonObjects, getDifferenceSummary, normalizeJsonObject, } from '../../utils/json-comparator.js';
+describe('json-comparator', () => {
+    describe('compareJsonObjects', () => {
+        it('should return true for identical objects', () => {
+            const obj1 = { a: 1, b: 'test', c: [1, 2, 3] };
+            const obj2 = { a: 1, b: 'test', c: [1, 2, 3] };
+            const result = compareJsonObjects(obj1, obj2);
+            expect(result.isEqual).toBe(true);
+            expect(result.differences).toHaveLength(0);
+        });
+        it('should return false for different objects', () => {
+            const obj1 = { a: 1, b: 'test' };
+            const obj2 = { a: 2, b: 'test' };
+            const result = compareJsonObjects(obj1, obj2);
+            expect(result.isEqual).toBe(false);
+            expect(result.differences).toHaveLength(1);
+            expect(result.differences[0].path).toBe('a');
+            expect(result.differences[0].type).toBe('different');
+        });
+        it('should handle arrays with different order when ignoreArrayOrder is true', () => {
+            const obj1 = { items: [1, 2, 3] };
+            const obj2 = { items: [3, 1, 2] };
+            const result = compareJsonObjects(obj1, obj2, { ignoreArrayOrder: true });
+            expect(result.isEqual).toBe(true);
+        });
+        it('should detect arrays with different order when ignoreArrayOrder is false', () => {
+            const obj1 = { items: [1, 2, 3] };
+            const obj2 = { items: [3, 1, 2] };
+            const result = compareJsonObjects(obj1, obj2, { ignoreArrayOrder: false });
+            expect(result.isEqual).toBe(false);
+        });
+        it('should handle missing keys', () => {
+            const obj1 = { a: 1, b: 2 };
+            const obj2 = { a: 1 };
+            const result = compareJsonObjects(obj1, obj2);
+            expect(result.isEqual).toBe(false);
+            expect(result.differences).toHaveLength(1);
+            expect(result.differences[0].type).toBe('extra');
+            expect(result.differences[0].path).toBe('b');
+        });
+        it('should handle extra keys', () => {
+            const obj1 = { a: 1 };
+            const obj2 = { a: 1, b: 2 };
+            const result = compareJsonObjects(obj1, obj2);
+            expect(result.isEqual).toBe(false);
+            expect(result.differences).toHaveLength(1);
+            expect(result.differences[0].type).toBe('missing');
+            expect(result.differences[0].path).toBe('b');
+        });
+        it('should handle nested objects', () => {
+            const obj1 = { user: { name: 'John', age: 30 } };
+            const obj2 = { user: { name: 'John', age: 31 } };
+            const result = compareJsonObjects(obj1, obj2);
+            expect(result.isEqual).toBe(false);
+            expect(result.differences).toHaveLength(1);
+            expect(result.differences[0].path).toBe('user.age');
+        });
+        it('should handle type mismatches', () => {
+            const obj1 = { value: '123' };
+            const obj2 = { value: 123 };
+            const result = compareJsonObjects(obj1, obj2);
+            expect(result.isEqual).toBe(false);
+            expect(result.differences).toHaveLength(1);
+            expect(result.differences[0].type).toBe('type_mismatch');
+        });
+        it('should ignore specified paths', () => {
+            const obj1 = { a: 1, b: 2, c: 3 };
+            const obj2 = { a: 1, b: 999, c: 3 };
+            const result = compareJsonObjects(obj1, obj2, { ignorePaths: ['b'] });
+            expect(result.isEqual).toBe(true);
+        });
+        it('should ignore paths with wildcards', () => {
+            const obj1 = { user: { name: 'John', age: 30 }, meta: { created: '2023-01-01' } };
+            const obj2 = { user: { name: 'John', age: 30 }, meta: { created: '2023-01-02' } };
+            const result = compareJsonObjects(obj1, obj2, { ignorePaths: ['meta.*'] });
+            expect(result.isEqual).toBe(true);
+        });
+        it('should handle case insensitive comparison', () => {
+            const obj1 = { name: 'John' };
+            const obj2 = { name: 'JOHN' };
+            const result = compareJsonObjects(obj1, obj2, { ignoreCase: true });
+            expect(result.isEqual).toBe(true);
+        });
+        it('should handle whitespace insensitive comparison', () => {
+            const obj1 = { description: 'Hello world' };
+            const obj2 = { description: '  Hello   world  ' };
+            const result = compareJsonObjects(obj1, obj2, { ignoreWhitespace: true });
+            expect(result.isEqual).toBe(true);
+        });
+        it('should provide accurate statistics', () => {
+            const obj1 = { a: 1, b: 2, c: 3 };
+            const obj2 = { a: 1, b: 999, d: 4 };
+            const result = compareJsonObjects(obj1, obj2);
+            expect(result.stats.totalKeys).toBe(4);
+            expect(result.stats.differentKeys).toBe(1); // 'b' has different values
+            expect(result.stats.missingKeys).toBe(1); // 'd' is missing in obj1
+            expect(result.stats.extraKeys).toBe(1); // 'c' is extra in obj1
+        });
+    });
+    describe('normalizeJsonObject', () => {
+        it('should normalize strings with case and whitespace options', () => {
+            const obj = { name: '  John DOE  ', items: ['A', 'B', 'C'] };
+            const normalized = normalizeJsonObject(obj, {
+                ignoreCase: true,
+                ignoreWhitespace: true,
+                ignoreArrayOrder: true,
+            });
+            expect(normalized.name).toBe('john doe');
+            expect(normalized.items).toEqual(['a', 'b', 'c']); // Sorted alphabetically and case normalized
+        });
+        it('should sort object keys', () => {
+            const obj = { c: 3, a: 1, b: 2 };
+            const normalized = normalizeJsonObject(obj);
+            expect(Object.keys(normalized)).toEqual(['a', 'b', 'c']);
+        });
+        it('should handle nested objects', () => {
+            const obj = { user: { name: 'John', age: 30 }, meta: { version: '1.0' } };
+            const normalized = normalizeJsonObject(obj);
+            expect(Object.keys(normalized)).toEqual(['meta', 'user']);
+            expect(Object.keys(normalized.user)).toEqual(['age', 'name']);
+        });
+    });
+    describe('getDifferenceSummary', () => {
+        it('should return success message for equal objects', () => {
+            const result = {
+                isEqual: true,
+                differences: [],
+                stats: { totalKeys: 0, differentKeys: 0, missingKeys: 0, extraKeys: 0 },
+            };
+            const summary = getDifferenceSummary(result);
+            expect(summary).toBe('✅ Objects are equivalent');
+        });
+        it('should return detailed summary for different objects', () => {
+            const result = {
+                isEqual: false,
+                differences: [
+                    {
+                        path: 'a',
+                        type: 'different',
+                        value1: 1,
+                        value2: 2,
+                        description: 'Value mismatch',
+                    },
+                    { path: 'b', type: 'missing', value2: 3, description: 'Missing key' },
+                ],
+                stats: { totalKeys: 2, differentKeys: 1, missingKeys: 1, extraKeys: 0 },
+            };
+            const summary = getDifferenceSummary(result);
+            expect(summary).toContain('❌ Objects differ');
+            expect(summary).toContain('Total keys: 2');
+            expect(summary).toContain('Different values: 1');
+            expect(summary).toContain('Missing keys: 1');
+            expect(summary).toContain('a: Value mismatch');
+            expect(summary).toContain('b: Missing key');
+        });
+        it('should limit displayed differences to 10', () => {
+            const differences = Array.from({ length: 15 }, (_, i) => ({
+                path: `key${i}`,
+                type: 'different',
+                value1: i,
+                value2: i + 1,
+                description: `Difference ${i}`,
+            }));
+            const result = {
+                isEqual: false,
+                differences,
+                stats: { totalKeys: 15, differentKeys: 15, missingKeys: 0, extraKeys: 0 },
+            };
+            const summary = getDifferenceSummary(result);
+            expect(summary).toContain('... and 5 more differences');
+        });
+    });
+});

package/dist/__tests__/utils/port-manager.test.d.ts

@@ -0,0 +1 @@
+export {};