@inkeep/agents-cli 0.1.5 → 0.1.7

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

@@ -1,186 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
-import { initCommand } from '../../commands/init.js';
-// Mock inquirer
-vi.mock('inquirer', () => ({
-    default: {
-        prompt: vi.fn(),
-    },
-}));
-// Mock fs functions
-vi.mock('node:fs', async () => {
-    const actual = await vi.importActual('node:fs');
-    return {
-        ...actual,
-        existsSync: vi.fn(),
-        writeFileSync: vi.fn(),
-        readdirSync: vi.fn(),
-    };
-});
-describe('Init Command', () => {
-    let consoleLogSpy;
-    let consoleErrorSpy;
-    let processExitSpy;
-    beforeEach(() => {
-        consoleLogSpy = vi.spyOn(console, 'log').mockImplementation(() => { });
-        consoleErrorSpy = vi.spyOn(console, 'error').mockImplementation(() => { });
-        processExitSpy = vi.spyOn(process, 'exit').mockImplementation(() => {
-            throw new Error('process.exit called');
-        });
-        vi.clearAllMocks();
-    });
-    afterEach(() => {
-        consoleLogSpy.mockRestore();
-        consoleErrorSpy.mockRestore();
-        processExitSpy.mockRestore();
-    });
-    describe('initCommand', () => {
-        it('should create a new config file when none exists', async () => {
-            const { existsSync, writeFileSync, readdirSync } = await import('node:fs');
-            const inquirer = await import('inquirer');
-            vi.mocked(existsSync).mockReturnValue(false);
-            vi.mocked(readdirSync).mockReturnValue(['package.json']);
-            const promptMock = vi.mocked(inquirer.default.prompt);
-            promptMock
-                .mockResolvedValueOnce({
-                confirmedPath: './inkeep.config.ts',
-            })
-                .mockResolvedValueOnce({
-                tenantId: 'test-tenant-123',
-                apiUrl: 'http://localhost:3002',
-            });
-            await initCommand();
-            expect(existsSync).toHaveBeenCalledWith(expect.stringContaining('inkeep.config.ts'));
-            expect(writeFileSync).toHaveBeenCalledWith(expect.stringContaining('inkeep.config.ts'), expect.stringContaining("tenantId: 'test-tenant-123'"));
-            expect(writeFileSync).toHaveBeenCalledWith(expect.stringContaining('inkeep.config.ts'), expect.stringContaining("apiUrl: 'http://localhost:3002'"));
-            expect(consoleLogSpy).toHaveBeenCalledWith(expect.any(String), // The checkmark
-            expect.stringContaining('Created'));
-        });
-        it('should prompt for overwrite when config file exists', async () => {
-            const { existsSync, writeFileSync, readdirSync } = await import('node:fs');
-            const inquirer = await import('inquirer');
-            vi.mocked(readdirSync).mockReturnValue(['package.json']);
-            vi.mocked(existsSync).mockImplementation((path) => {
-                return path.toString().includes('inkeep.config.ts');
-            });
-            const promptMock = vi.mocked(inquirer.default.prompt);
-            promptMock
-                .mockResolvedValueOnce({ confirmedPath: './inkeep.config.ts' })
-                .mockResolvedValueOnce({ overwrite: true })
-                .mockResolvedValueOnce({
-                tenantId: 'new-tenant-456',
-                apiUrl: 'https://api.example.com',
-            });
-            await initCommand();
-            expect(inquirer.default.prompt).toHaveBeenCalledWith(expect.arrayContaining([
-                expect.objectContaining({
-                    type: 'confirm',
-                    name: 'overwrite',
-                    message: expect.stringContaining('already exists'),
-                }),
-            ]));
-            expect(writeFileSync).toHaveBeenCalledWith(expect.stringContaining('inkeep.config.ts'), expect.stringContaining("tenantId: 'new-tenant-456'"));
-        });
-        it('should cancel when user chooses not to overwrite', async () => {
-            const { existsSync, writeFileSync, readdirSync } = await import('node:fs');
-            const inquirer = await import('inquirer');
-            vi.mocked(readdirSync).mockReturnValue(['package.json']);
-            vi.mocked(existsSync).mockImplementation((path) => {
-                return path.toString().includes('inkeep.config.ts');
-            });
-            const promptMock = vi.mocked(inquirer.default.prompt);
-            promptMock
-                .mockResolvedValueOnce({ confirmedPath: './inkeep.config.ts' })
-                .mockResolvedValueOnce({ overwrite: false });
-            await initCommand();
-            expect(writeFileSync).not.toHaveBeenCalled();
-            expect(consoleLogSpy).toHaveBeenCalledWith(expect.stringContaining('Init cancelled'));
-        });
-        it('should validate tenant ID is not empty', async () => {
-            const { existsSync, readdirSync } = await import('node:fs');
-            const inquirer = await import('inquirer');
-            vi.mocked(existsSync).mockReturnValue(false);
-            vi.mocked(readdirSync).mockReturnValue(['package.json']);
-            let pathCallCount = 0;
-            const promptMock = vi.mocked(inquirer.default.prompt);
-            promptMock.mockImplementation(async (questions) => {
-                pathCallCount++;
-                if (pathCallCount === 1) {
-                    // First call is for path confirmation
-                    return { confirmedPath: './inkeep.config.ts' };
-                }
-                else {
-                    // Second call is for tenant ID and API URL
-                    const tenantIdQuestion = questions.find((q) => q.name === 'tenantId');
-                    expect(tenantIdQuestion.validate('')).toBe('Tenant ID is required');
-                    expect(tenantIdQuestion.validate('   ')).toBe('Tenant ID is required');
-                    expect(tenantIdQuestion.validate('valid-tenant')).toBe(true);
-                    return {
-                        tenantId: 'valid-tenant',
-                        apiUrl: 'http://localhost:3002',
-                    };
-                }
-            });
-            await initCommand();
-        });
-        it('should validate API URL format', async () => {
-            const { existsSync, readdirSync } = await import('node:fs');
-            const inquirer = await import('inquirer');
-            vi.mocked(existsSync).mockReturnValue(false);
-            vi.mocked(readdirSync).mockReturnValue(['package.json']);
-            let pathCallCount = 0;
-            const promptMock = vi.mocked(inquirer.default.prompt);
-            promptMock.mockImplementation(async (questions) => {
-                pathCallCount++;
-                if (pathCallCount === 1) {
-                    // First call is for path confirmation
-                    return { confirmedPath: './inkeep.config.ts' };
-                }
-                else {
-                    // Second call is for tenant ID and API URL
-                    const apiUrlQuestion = questions.find((q) => q.name === 'apiUrl');
-                    expect(apiUrlQuestion.validate('not-a-url')).toBe('Please enter a valid URL');
-                    expect(apiUrlQuestion.validate('http://localhost:3002')).toBe(true);
-                    expect(apiUrlQuestion.validate('https://api.example.com')).toBe(true);
-                    return {
-                        tenantId: 'test-tenant',
-                        apiUrl: 'http://localhost:3002',
-                    };
-                }
-            });
-            await initCommand();
-        });
-        it('should accept a path parameter', async () => {
-            const { existsSync, writeFileSync } = await import('node:fs');
-            const inquirer = await import('inquirer');
-            vi.mocked(existsSync).mockReturnValue(false);
-            const promptMock = vi.mocked(inquirer.default.prompt);
-            promptMock.mockResolvedValue({
-                tenantId: 'test-tenant',
-                apiUrl: 'http://localhost:3002',
-            });
-            await initCommand({ path: './custom/path' });
-            expect(writeFileSync).toHaveBeenCalledWith(expect.stringContaining('custom/path/inkeep.config.ts'), expect.any(String));
-        });
-        it('should handle write errors gracefully', async () => {
-            const { existsSync, writeFileSync, readdirSync } = await import('node:fs');
-            const inquirer = await import('inquirer');
-            vi.mocked(existsSync).mockReturnValue(false);
-            vi.mocked(readdirSync).mockReturnValue(['package.json']);
-            const promptMock = vi.mocked(inquirer.default.prompt);
-            promptMock
-                .mockResolvedValueOnce({
-                confirmedPath: './inkeep.config.ts',
-            })
-                .mockResolvedValueOnce({
-                tenantId: 'test-tenant',
-                apiUrl: 'http://localhost:3002',
-            });
-            vi.mocked(writeFileSync).mockImplementation(() => {
-                throw new Error('Permission denied');
-            });
-            await expect(initCommand()).rejects.toThrow('process.exit called');
-            expect(consoleErrorSpy).toHaveBeenCalledWith(expect.stringContaining('Failed to create config file'), expect.any(Error));
-            expect(processExitSpy).toHaveBeenCalledWith(1);
-        });
-    });
-});

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

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

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

@@ -1,54 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from 'vitest';
-import { convertTypeScriptToJson } from '../../commands/pull.js';
-// Mock the convertTypeScriptToJson function
-vi.mock('../../commands/pull.js', async () => {
-    const actual = await vi.importActual('../../commands/pull.js');
-    return {
-        ...actual,
-        convertTypeScriptToJson: vi.fn(),
-    };
-});
-describe('Pull Command', () => {
-    beforeEach(() => {
-        vi.clearAllMocks();
-    });
-    describe('convertTypeScriptToJson', () => {
-        it('should convert TypeScript file to JSON using tsx spawn', async () => {
-            const mockResult = { id: 'test-graph', name: 'Test Graph' };
-            convertTypeScriptToJson.mockResolvedValue(mockResult);
-            const result = await convertTypeScriptToJson('test-graph.ts');
-            expect(convertTypeScriptToJson).toHaveBeenCalledWith('test-graph.ts');
-            expect(result).toEqual(mockResult);
-        });
-        it('should handle tsx spawn errors', async () => {
-            convertTypeScriptToJson.mockRejectedValue(new Error('Failed to load TypeScript file: tsx not found'));
-            await expect(convertTypeScriptToJson('test-graph.ts')).rejects.toThrow('Failed to load TypeScript file: tsx not found');
-        });
-        it('should handle tsx exit with non-zero code', async () => {
-            convertTypeScriptToJson.mockRejectedValue(new Error('Conversion failed: Error: Module not found'));
-            await expect(convertTypeScriptToJson('test-graph.ts')).rejects.toThrow('Conversion failed: Error: Module not found');
-        });
-        it('should handle missing JSON markers in tsx output', async () => {
-            convertTypeScriptToJson.mockRejectedValue(new Error('JSON markers not found in output'));
-            await expect(convertTypeScriptToJson('test-graph.ts')).rejects.toThrow('JSON markers not found in output');
-        });
-        it('should handle invalid JSON in tsx output', async () => {
-            convertTypeScriptToJson.mockRejectedValue(new Error('Failed to parse conversion result'));
-            await expect(convertTypeScriptToJson('test-graph.ts')).rejects.toThrow('Failed to parse conversion result');
-        });
-        it('should handle file not found error', async () => {
-            convertTypeScriptToJson.mockRejectedValue(new Error('File not found: nonexistent.ts'));
-            await expect(convertTypeScriptToJson('nonexistent.ts')).rejects.toThrow('File not found: nonexistent.ts');
-        });
-        it('should handle non-TypeScript files directly', async () => {
-            const mockResult = { id: 'test-graph' };
-            convertTypeScriptToJson.mockResolvedValue(mockResult);
-            const result = await convertTypeScriptToJson('test-graph.js');
-            expect(result).toEqual(mockResult);
-        });
-        it('should handle modules with no graph exports', async () => {
-            convertTypeScriptToJson.mockRejectedValue(new Error('No AgentGraph exported from configuration file'));
-            await expect(convertTypeScriptToJson('test-graph.js')).rejects.toThrow('No AgentGraph exported from configuration file');
-        });
-    });
-});

package/dist/__tests__/commands/push-spinner.test.d.ts

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

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

@@ -1,127 +0,0 @@
-import { describe, it, expect, beforeEach, vi } from 'vitest';
-import { spawn } from 'node:child_process';
-import { pushCommand } from '../../commands/push.js';
-import { existsSync } from 'node:fs';
-// Mock dependencies
-vi.mock('node:fs');
-vi.mock('node:child_process');
-vi.mock('@inkeep/agents-core');
-vi.mock('../../config.js', () => ({
-    validateConfiguration: vi.fn().mockResolvedValue({
-        tenantId: 'test-tenant',
-        projectId: 'test-project',
-        managementApiUrl: 'http://localhost:3002',
-        sources: {
-            tenantId: 'config',
-            projectId: 'config',
-            managementApiUrl: 'config',
-        },
-    }),
-}));
-// Store the actual ora mock instance
-let oraInstance;
-vi.mock('ora', () => ({
-    default: vi.fn(() => {
-        oraInstance = {
-            start: vi.fn().mockReturnThis(),
-            succeed: vi.fn().mockReturnThis(),
-            fail: vi.fn().mockReturnThis(),
-            warn: vi.fn().mockReturnThis(),
-            stop: vi.fn().mockReturnThis(),
-            text: '',
-        };
-        return oraInstance;
-    }),
-}));
-describe('Push Command - TypeScript Spinner Fix', () => {
-    let mockSpawn;
-    let mockExit;
-    beforeEach(() => {
-        vi.clearAllMocks();
-        // Reset ora instance
-        oraInstance = null;
-        // Ensure TSX_RUNNING is not set
-        delete process.env.TSX_RUNNING;
-        // Mock file exists
-        existsSync.mockReturnValue(true);
-        // Mock process.exit
-        mockExit = vi.fn();
-        vi.spyOn(process, 'exit').mockImplementation(mockExit);
-        // Mock console methods
-        vi.spyOn(console, 'log').mockImplementation(vi.fn());
-        vi.spyOn(console, 'error').mockImplementation(vi.fn());
-        // Setup spawn mock
-        mockSpawn = vi.fn().mockReturnValue({
-            on: vi.fn((event, callback) => {
-                if (event === 'exit') {
-                    // Simulate successful exit
-                    setTimeout(() => callback(0), 10);
-                }
-            }),
-        });
-        spawn.mockImplementation(mockSpawn);
-    });
-    it('should stop spinner before spawning tsx process for TypeScript files', async () => {
-        await pushCommand('/test/path/graph.ts', {});
-        // Wait for async operations
-        await new Promise(resolve => setTimeout(resolve, 20));
-        // Verify spinner was created and stopped
-        expect(oraInstance).toBeDefined();
-        expect(oraInstance.start).toHaveBeenCalled();
-        expect(oraInstance.stop).toHaveBeenCalled();
-        // Verify spinner.stop() was called before spawn
-        const stopCallOrder = oraInstance.stop.mock.invocationCallOrder[0];
-        const spawnCallOrder = mockSpawn.mock.invocationCallOrder[0];
-        expect(stopCallOrder).toBeLessThan(spawnCallOrder);
-    });
-    it('should spawn tsx process with correct arguments for TypeScript files', async () => {
-        const options = {
-            tenantId: 'custom-tenant',
-            managementApiUrl: 'https://api.example.com',
-            configFilePath: '/path/to/config.json',
-        };
-        await pushCommand('/test/path/graph.ts', options);
-        // Wait for async operations
-        await new Promise(resolve => setTimeout(resolve, 20));
-        // Verify spawn was called with correct arguments
-        expect(mockSpawn).toHaveBeenCalledWith('npx', expect.arrayContaining([
-            'tsx',
-            expect.stringContaining('index.js'),
-            'push',
-            '/test/path/graph.ts',
-            '--tenant-id',
-            'custom-tenant',
-            '--management-api-url',
-            'https://api.example.com',
-            '--config-file-path',
-            '/path/to/config.json',
-        ]), expect.objectContaining({
-            cwd: process.cwd(),
-            stdio: 'inherit',
-            env: expect.objectContaining({
-                TSX_RUNNING: '1',
-            }),
-        }));
-    });
-    it('should handle spawn errors correctly without spinner', async () => {
-        // Setup spawn to simulate an error
-        mockSpawn.mockReturnValue({
-            on: vi.fn((event, callback) => {
-                if (event === 'error') {
-                    setTimeout(() => callback(new Error('Spawn failed')), 10);
-                }
-            }),
-        });
-        await pushCommand('/test/path/graph.ts', {});
-        // Wait for async operations
-        await new Promise(resolve => setTimeout(resolve, 20));
-        // Verify spinner was stopped before error handling
-        expect(oraInstance.stop).toHaveBeenCalled();
-        // Verify error was logged without using spinner.fail
-        expect(oraInstance.fail).not.toHaveBeenCalled();
-        expect(console.error).toHaveBeenCalledWith(expect.stringContaining('Failed to load TypeScript file'));
-        expect(console.error).toHaveBeenCalledWith(expect.stringContaining('Error'), 'Spawn failed');
-        // Verify process exited with error code
-        expect(mockExit).toHaveBeenCalledWith(1);
-    });
-});

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

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

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

@@ -1,265 +0,0 @@
-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

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