@inkeep/agents-cli 0.1.0

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

@@ -0,0 +1,186 @@
+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-retry.test.d.ts

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

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

@@ -0,0 +1,156 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { pullCommand } from '../../commands/pull.js';
+// Mock dependencies
+vi.mock('../../config.js', () => ({
+    validateConfiguration: vi.fn().mockResolvedValue({
+        tenantId: 'test-tenant',
+        projectId: 'test-project',
+        apiUrl: 'http://test-api.com',
+        sources: {
+            tenantId: 'env',
+            projectId: 'env',
+            apiUrl: 'env',
+        },
+        modelConfig: {
+            model: 'anthropic/claude-3-5-sonnet-20241022',
+            providerOptions: { anthropic: {} },
+        },
+    }),
+}));
+vi.mock('../../commands/pull.llm-generate.js', () => ({
+    generateTypeScriptFileWithLLM: vi.fn(),
+}));
+vi.mock('../../utils/graph-converter.js', () => ({
+    convertTypeScriptToJson: vi.fn(),
+}));
+vi.mock('../../utils/json-comparator.js', () => ({
+    compareJsonObjects: vi.fn(),
+    getDifferenceSummary: vi.fn(),
+}));
+vi.mock('node:fs', () => ({
+    existsSync: vi.fn().mockReturnValue(true),
+    mkdirSync: vi.fn(),
+    writeFileSync: vi.fn(),
+}));
+vi.mock('node:path', () => ({
+    join: vi.fn((...args) => args.join('/')),
+    resolve: vi.fn((...args) => args.join('/')),
+}));
+describe('pull command retry functionality', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+    it('should retry LLM generation when validation fails', async () => {
+        const { generateTypeScriptFileWithLLM } = await import('../../commands/pull.llm-generate.js');
+        const { convertTypeScriptToJson } = await import('../../commands/pull.js');
+        const { compareJsonObjects } = await import('../../utils/json-comparator.js');
+        // Mock fetch to return graph data
+        global.fetch = vi.fn().mockResolvedValue({
+            ok: true,
+            json: () => Promise.resolve({
+                data: {
+                    id: 'test-graph',
+                    name: 'Test Graph',
+                    agents: [],
+                },
+            }),
+        });
+        // Mock validation to fail first time, then succeed
+        vi.mocked(compareJsonObjects)
+            .mockReturnValueOnce({
+            isEqual: false,
+            differences: [
+                {
+                    path: 'agents[0].id',
+                    type: 'different',
+                    value1: 'agent1',
+                    value2: 'agent2',
+                    description: 'ID mismatch',
+                },
+            ],
+            stats: { totalKeys: 1, differentKeys: 1, missingKeys: 0, extraKeys: 0 },
+        })
+            .mockReturnValueOnce({
+            isEqual: true,
+            differences: [],
+            stats: { totalKeys: 1, differentKeys: 0, missingKeys: 0, extraKeys: 0 },
+        });
+        vi.mocked(convertTypeScriptToJson).mockResolvedValue({
+            id: 'test-graph',
+            name: 'Test Graph',
+            agents: [],
+            tools: [],
+            contextConfigs: [],
+            credentialReferences: [],
+        });
+        vi.mocked(generateTypeScriptFileWithLLM).mockResolvedValue(undefined);
+        // Mock process.exit to prevent actual exit
+        const originalExit = process.exit;
+        process.exit = vi.fn();
+        try {
+            await pullCommand('test-graph', { maxRetries: 2 });
+            // Verify that generateTypeScriptFileWithLLM was called twice (initial + retry)
+            expect(generateTypeScriptFileWithLLM).toHaveBeenCalledTimes(2);
+            // Verify retry context was passed on second call
+            const secondCall = vi.mocked(generateTypeScriptFileWithLLM).mock.calls[1];
+            expect(secondCall[4]).toEqual({
+                attempt: 2,
+                maxRetries: 2,
+                previousDifferences: ['agents[0].id: ID mismatch'],
+            });
+        }
+        finally {
+            process.exit = originalExit;
+        }
+    });
+    it('should fail after max retries exceeded', async () => {
+        const { generateTypeScriptFileWithLLM } = await import('../../commands/pull.llm-generate.js');
+        const { convertTypeScriptToJson } = await import('../../commands/pull.js');
+        const { compareJsonObjects } = await import('../../utils/json-comparator.js');
+        // Mock fetch to return graph data
+        global.fetch = vi.fn().mockResolvedValue({
+            ok: true,
+            json: () => Promise.resolve({
+                data: {
+                    id: 'test-graph',
+                    name: 'Test Graph',
+                    agents: [],
+                },
+            }),
+        });
+        // Mock validation to always fail
+        vi.mocked(compareJsonObjects).mockReturnValue({
+            isEqual: false,
+            differences: [
+                {
+                    path: 'agents[0].id',
+                    type: 'different',
+                    value1: 'agent1',
+                    value2: 'agent2',
+                    description: 'ID mismatch',
+                },
+            ],
+            stats: { totalKeys: 1, differentKeys: 1, missingKeys: 0, extraKeys: 0 },
+        });
+        vi.mocked(convertTypeScriptToJson).mockResolvedValue({
+            id: 'test-graph',
+            name: 'Test Graph',
+            agents: [],
+            tools: [],
+            contextConfigs: [],
+            credentialReferences: [],
+        });
+        vi.mocked(generateTypeScriptFileWithLLM).mockResolvedValue(undefined);
+        // Mock process.exit to prevent actual exit
+        const originalExit = process.exit;
+        process.exit = vi.fn();
+        try {
+            await pullCommand('test-graph', { maxRetries: 2 });
+            // Verify that generateTypeScriptFileWithLLM was called the maximum number of times
+            expect(generateTypeScriptFileWithLLM).toHaveBeenCalledTimes(2);
+        }
+        finally {
+            process.exit = originalExit;
+        }
+    });
+});

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

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

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

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

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

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

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

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