@agents-at-scale/ark 0.1.52 → 0.1.55

package/dist/commands/marketplace/index.spec.js

@@ -1,88 +0,0 @@
-import { jest } from '@jest/globals';
-import { Command } from 'commander';
-const mockGetAllMarketplaceServices = jest.fn();
-const mockGetAllMarketplaceAgents = jest.fn();
-const mockFetchMarketplaceManifest = jest.fn();
-const mockConsoleLog = jest.spyOn(console, 'log').mockImplementation(() => { });
-jest.unstable_mockModule('../../marketplaceServices.js', () => ({
-    getAllMarketplaceServices: mockGetAllMarketplaceServices,
-    getAllMarketplaceAgents: mockGetAllMarketplaceAgents,
-}));
-jest.unstable_mockModule('../../lib/marketplaceFetcher.js', () => ({
-    fetchMarketplaceManifest: mockFetchMarketplaceManifest,
-}));
-const { createMarketplaceCommand } = await import('./index.js');
-describe('marketplace command', () => {
-    beforeEach(() => {
-        jest.clearAllMocks();
-    });
-    it('creates marketplace command with correct structure', () => {
-        const command = createMarketplaceCommand({});
-        expect(command).toBeInstanceOf(Command);
-        expect(command.name()).toBe('marketplace');
-    });
-    it('lists services and agents from manifest', async () => {
-        const mockServices = {
-            'test-service': {
-                name: 'test-service',
-                helmReleaseName: 'test-service',
-                description: 'Test service description',
-                enabled: true,
-                category: 'marketplace',
-                namespace: 'test-ns',
-            },
-        };
-        const mockAgents = {
-            'test-agent': {
-                name: 'test-agent',
-                helmReleaseName: 'test-agent',
-                description: 'Test agent description',
-                enabled: true,
-                category: 'marketplace',
-                namespace: 'test-ns',
-            },
-        };
-        const mockManifest = {
-            version: '1.0.0',
-            marketplace: 'ARK Marketplace',
-            items: [
-                {
-                    name: 'test-service',
-                    description: 'Test service',
-                    type: 'service',
-                    ark: {
-                        chartPath: 'oci://registry/test-service',
-                        namespace: 'test',
-                    },
-                },
-                {
-                    name: 'test-agent',
-                    description: 'Test agent',
-                    type: 'agent',
-                    ark: {
-                        chartPath: 'oci://registry/test-agent',
-                        namespace: 'test',
-                    },
-                },
-            ],
-        };
-        mockGetAllMarketplaceServices.mockResolvedValue(mockServices);
-        mockGetAllMarketplaceAgents.mockResolvedValue(mockAgents);
-        mockFetchMarketplaceManifest.mockResolvedValue(mockManifest);
-        const command = createMarketplaceCommand({});
-        await command.parseAsync(['node', 'test', 'list']);
-        expect(mockGetAllMarketplaceServices).toHaveBeenCalled();
-        expect(mockGetAllMarketplaceAgents).toHaveBeenCalled();
-        expect(mockConsoleLog).toHaveBeenCalled();
-    });
-    it('shows unavailable message when marketplace unavailable', async () => {
-        mockGetAllMarketplaceServices.mockResolvedValue(null);
-        mockGetAllMarketplaceAgents.mockResolvedValue(null);
-        mockFetchMarketplaceManifest.mockResolvedValue(null);
-        const command = createMarketplaceCommand({});
-        await command.parseAsync(['node', 'test', 'list']);
-        expect(mockConsoleLog).toHaveBeenCalled();
-        const logCalls = mockConsoleLog.mock.calls.map((c) => c[0]).join(' ');
-        expect(logCalls).toContain('unavailable');
-    });
-});

package/dist/commands/memory/index.spec.d.ts

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

package/dist/commands/memory/index.spec.js

@@ -1,124 +0,0 @@
-import { describe, it, expect, jest, beforeEach, afterEach, beforeAll, } from '@jest/globals';
-// ESM-safe mocking: declare variables to hold dynamically imported modules
-let createMemoryCommand;
-let deleteSession;
-let deleteQuery;
-let deleteAll;
-let ArkApiProxy;
-let output;
-// Mock dependencies
-jest.unstable_mockModule('../../lib/output.js', () => ({
-    default: {
-        info: jest.fn(),
-        success: jest.fn(),
-        error: jest.fn(),
-    },
-}));
-// Mock ArkApiProxy with a simpler approach
-jest.unstable_mockModule('../../lib/arkApiProxy.js', () => ({
-    __esModule: true,
-    ArkApiProxy: jest.fn().mockImplementation(() => ({
-        start: jest.fn(),
-        stop: jest.fn(),
-    })),
-}));
-beforeAll(async () => {
-    // After mocks are registered, dynamically import modules
-    ({ ArkApiProxy } = await import('../../lib/arkApiProxy.js'));
-    ({ default: output } = await import('../../lib/output.js'));
-    ({ createMemoryCommand, deleteSession, deleteQuery, deleteAll } = await import('./index.js'));
-});
-describe('Memory Command', () => {
-    let mockConfig;
-    beforeEach(() => {
-        jest.clearAllMocks();
-        mockConfig = {};
-    });
-    afterEach(() => {
-        jest.restoreAllMocks();
-    });
-    describe('Command Structure', () => {
-        it('should create memory command with correct structure', () => {
-            const command = createMemoryCommand(mockConfig);
-            expect(command.name()).toBe('memory');
-            expect(command.alias()).toBe('mem');
-            expect(command.description()).toBe('Manage memory sessions and queries');
-        });
-        it('should have list subcommand', () => {
-            const command = createMemoryCommand(mockConfig);
-            const subcommands = command.commands.map((cmd) => cmd.name());
-            expect(subcommands).toContain('list');
-        });
-        it('should have delete subcommand with nested commands and flags', () => {
-            const command = createMemoryCommand(mockConfig);
-            const deleteCommand = command.commands.find((cmd) => cmd.name() === 'delete');
-            expect(deleteCommand).toBeDefined();
-            expect(deleteCommand?.description()).toBe('Delete memory data');
-            const deleteSubcommands = deleteCommand?.commands.map((cmd) => cmd.name()) || [];
-            expect(deleteSubcommands).toContain('session');
-            expect(deleteSubcommands).toContain('query');
-            // --all flag is supported on the delete root instead of an 'all' subcommand
-        });
-    });
-    describe('Command Creation', () => {
-        it('should create command without errors', () => {
-            expect(() => createMemoryCommand(mockConfig)).not.toThrow();
-        });
-        it('should return a command object', () => {
-            const command = createMemoryCommand(mockConfig);
-            expect(command).toBeDefined();
-            expect(typeof command.name).toBe('function');
-            expect(typeof command.description).toBe('function');
-        });
-    });
-    describe('Error Scenarios', () => {
-        let exitSpy;
-        beforeEach(async () => {
-            exitSpy = jest
-                .spyOn(process, 'exit')
-                .mockImplementation(((..._args) => undefined));
-        });
-        afterEach(() => {
-            exitSpy.mockRestore();
-        });
-        it('deleteSession handles 500 error', async () => {
-            const err = new Error('Internal Server Error');
-            const fakeClient = {
-                deleteSession: jest.fn().mockRejectedValue(err),
-            };
-            ArkApiProxy.mockImplementation(() => ({
-                start: jest.fn().mockResolvedValue(fakeClient),
-                stop: jest.fn(),
-            }));
-            await deleteSession('sess-1', { output: 'text' }).catch(() => { });
-            expect(output.error).toHaveBeenCalled();
-            expect(process.exit).toHaveBeenCalledWith(1);
-        });
-        it('deleteQuery handles network timeout', async () => {
-            const err = new Error('Network timeout');
-            const fakeClient = {
-                deleteQueryMessages: jest.fn().mockRejectedValue(err),
-            };
-            ArkApiProxy.mockImplementation(() => ({
-                start: jest.fn().mockResolvedValue(fakeClient),
-                stop: jest.fn(),
-            }));
-            await deleteQuery('sess-2', 'query-9', { output: 'text' }).catch(() => { });
-            expect(output.error).toHaveBeenCalled();
-            expect(process.exit).toHaveBeenCalledWith(1);
-        });
-        it('deleteAll handles no memory services reachable', async () => {
-            const err = new Error('No memory services reachable');
-            const fakeClient = {
-                deleteAllSessions: jest.fn().mockRejectedValue(err),
-            };
-            ArkApiProxy.mockImplementation(() => ({
-                start: jest.fn().mockResolvedValue(fakeClient),
-                stop: jest.fn(),
-            }));
-            await deleteAll({ output: 'text' }).catch(() => { });
-            expect(output.error).toHaveBeenCalled();
-            expect(process.exit).toHaveBeenCalledWith(1);
-        });
-    });
-});

package/dist/commands/models/create.spec.d.ts

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

package/dist/commands/models/create.spec.js

@@ -1,167 +0,0 @@
-import { jest } from '@jest/globals';
-const mockExeca = jest.fn();
-jest.unstable_mockModule('execa', () => ({
-    execa: mockExeca,
-}));
-const mockInquirer = {
-    prompt: jest.fn(),
-};
-jest.unstable_mockModule('inquirer', () => ({
-    default: mockInquirer,
-}));
-const mockOutput = {
-    info: jest.fn(),
-    warning: jest.fn(),
-    error: jest.fn(),
-    success: jest.fn(),
-};
-jest.unstable_mockModule('../../lib/output.js', () => ({
-    default: mockOutput,
-}));
-jest.spyOn(console, 'log').mockImplementation(() => { });
-jest.spyOn(console, 'error').mockImplementation(() => { });
-const { createModel } = await import('./create.js');
-describe('createModel', () => {
-    beforeEach(() => {
-        jest.clearAllMocks();
-    });
-    it('creates new model for type aws bedrock', async () => {
-        mockExeca.mockRejectedValueOnce(new Error('not found')); // model doesn't exist
-        mockInquirer.prompt
-            .mockResolvedValueOnce({ modelType: 'bedrock' }) // user selects from list
-            .mockResolvedValueOnce({ model: 'anthropic.claude-3-sonnet-20240229-v1:0' })
-            .mockResolvedValueOnce({ region: 'us-east-1' })
-            .mockResolvedValueOnce({ accessKeyId: 'AKIAIOSFODNN7EXAMPLE' })
-            .mockResolvedValueOnce({
-            secretAccessKey: 'wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY',
-        })
-            .mockResolvedValueOnce({ sessionToken: 'optional-session-token' })
-            .mockResolvedValueOnce({
-            modelArn: 'arn:aws:bedrock:us-east-1:123456789012:model/anthropic.claude-3-sonnet-20240229-v1:0',
-        });
-        mockExeca.mockResolvedValue({}); // kubectl ops succeed
-        await createModel('test-model');
-        // Verify that model type prompt was called
-        expect(mockInquirer.prompt).toHaveBeenCalledWith([
-            expect.objectContaining({
-                type: 'list',
-                name: 'modelType',
-                message: 'select model provider:',
-                choices: expect.arrayContaining([
-                    { name: 'Azure OpenAI', value: 'azure' },
-                    { name: 'OpenAI', value: 'openai' },
-                    { name: 'AWS Bedrock', value: 'bedrock' },
-                ]),
-            }),
-        ]);
-        // Verify Bedrock-specific prompts were called
-        expect(mockInquirer.prompt).toHaveBeenCalledWith([
-            expect.objectContaining({
-                name: 'region',
-                message: 'AWS region:',
-            }),
-        ]);
-        expect(mockInquirer.prompt).toHaveBeenCalledWith([
-            expect.objectContaining({
-                name: 'accessKeyId',
-                message: 'AWS access key ID:',
-            }),
-        ]);
-        expect(mockInquirer.prompt).toHaveBeenCalledWith([
-            expect.objectContaining({
-                name: 'secretAccessKey',
-                message: 'AWS secret access key:',
-                type: 'password',
-            }),
-        ]);
-        expect(mockOutput.success).toHaveBeenCalledWith('model test-model created');
-    });
-    it('creates new model with provided name', async () => {
-        // Model doesn't exist
-        mockExeca.mockRejectedValueOnce(new Error('not found'));
-        // Prompts for model details
-        mockInquirer.prompt
-            .mockResolvedValueOnce({ modelType: 'openai' })
-            .mockResolvedValueOnce({ model: 'gpt-4' })
-            .mockResolvedValueOnce({ baseUrl: 'https://api.openai.com/' })
-            .mockResolvedValueOnce({ apiKey: 'secret-key' });
-        // Secret operations succeed
-        mockExeca.mockResolvedValueOnce({}); // create secret
-        mockExeca.mockResolvedValueOnce({}); // apply model
-        const result = await createModel('test-model');
-        expect(result).toBe(true);
-        expect(mockExeca).toHaveBeenCalledWith('kubectl', ['get', 'model', 'test-model'], { stdio: 'pipe' });
-        expect(mockOutput.success).toHaveBeenCalledWith('model test-model created');
-    });
-    it('prompts for name when not provided', async () => {
-        mockInquirer.prompt
-            .mockResolvedValueOnce({ modelName: 'prompted-model' })
-            .mockResolvedValueOnce({ modelType: 'azure' })
-            .mockResolvedValueOnce({ model: 'gpt-4' })
-            .mockResolvedValueOnce({ baseUrl: 'https://azure.com' })
-            .mockResolvedValueOnce({ apiVersion: '2024-12-01' })
-            .mockResolvedValueOnce({ apiKey: 'secret' });
-        mockExeca.mockRejectedValueOnce(new Error('not found')); // model doesn't exist
-        mockExeca.mockResolvedValue({}); // all kubectl ops succeed
-        const result = await createModel();
-        expect(result).toBe(true);
-        expect(mockInquirer.prompt).toHaveBeenCalledWith([
-            expect.objectContaining({
-                name: 'modelName',
-                message: 'model name:',
-            }),
-        ]);
-    });
-    it('handles overwrite confirmation when model exists', async () => {
-        // Model exists
-        mockExeca.mockResolvedValueOnce({});
-        mockInquirer.prompt
-            .mockResolvedValueOnce({ overwrite: true })
-            .mockResolvedValueOnce({ modelType: 'openai' })
-            .mockResolvedValueOnce({ model: 'gpt-4' })
-            .mockResolvedValueOnce({ baseUrl: 'https://api.openai.com' })
-            .mockResolvedValueOnce({ apiKey: 'secret' });
-        mockExeca.mockResolvedValue({}); // remaining kubectl ops
-        const result = await createModel('existing-model');
-        expect(result).toBe(true);
-        expect(mockOutput.warning).toHaveBeenCalledWith('model existing-model already exists');
-    });
-    it('cancels when user declines overwrite', async () => {
-        mockExeca.mockResolvedValueOnce({}); // model exists
-        mockInquirer.prompt.mockResolvedValueOnce({ overwrite: false });
-        const result = await createModel('existing-model');
-        expect(result).toBe(false);
-        expect(mockOutput.info).toHaveBeenCalledWith('model creation cancelled');
-    });
-    it('handles secret creation failure', async () => {
-        mockExeca
-            .mockRejectedValueOnce(new Error('not found')); // model doesn't exist
-        mockInquirer.prompt
-            .mockResolvedValueOnce({ modelType: 'openai' })
-            .mockResolvedValueOnce({ model: 'gpt-4' })
-            .mockResolvedValueOnce({ baseUrl: 'https://api.openai.com' })
-            .mockResolvedValueOnce({ apiKey: 'secret' });
-        mockExeca
-            .mockRejectedValueOnce(new Error('not found')); // secret doesn't exist check
-        mockExeca.mockRejectedValueOnce(new Error('secret creation failed')); // create secret fails
-        const result = await createModel('test-model');
-        expect(result).toBe(false);
-        expect(mockOutput.error).toHaveBeenCalledWith('failed to create secret');
-    });
-    it('updates existing secret when secret already exists', async () => {
-        mockExeca.mockRejectedValueOnce(new Error('not found')); // model doesn't exist
-        mockInquirer.prompt
-            .mockResolvedValueOnce({ modelType: 'openai' })
-            .mockResolvedValueOnce({ model: 'gpt-4' })
-            .mockResolvedValueOnce({ baseUrl: 'https://api.openai.com' })
-            .mockResolvedValueOnce({ apiKey: 'new-secret-key' });
-        mockExeca.mockResolvedValueOnce({}); // secret exists check
-        mockExeca.mockResolvedValueOnce({ stdout: 'secret yaml' }); // dry-run output
-        mockExeca.mockResolvedValueOnce({}); // kubectl apply
-        mockExeca.mockResolvedValueOnce({}); // apply model
-        const result = await createModel('test-model');
-        expect(result).toBe(true);
-        expect(mockOutput.success).toHaveBeenCalledWith('updated secret test-model-model-secret');
-        expect(mockOutput.success).toHaveBeenCalledWith('model test-model created');
-    });
-});

package/dist/commands/models/index.spec.d.ts

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

package/dist/commands/models/index.spec.js

@@ -1,96 +0,0 @@
-import { jest } from '@jest/globals';
-import { Command } from 'commander';
-const mockExeca = jest.fn();
-jest.unstable_mockModule('execa', () => ({
-    execa: mockExeca,
-}));
-const mockOutput = {
-    info: jest.fn(),
-    error: jest.fn(),
-};
-jest.unstable_mockModule('../../lib/output.js', () => ({
-    default: mockOutput,
-}));
-const mockCreateModel = jest.fn();
-jest.unstable_mockModule('./create.js', () => ({
-    createModel: mockCreateModel,
-}));
-const mockExecuteQuery = jest.fn();
-jest.unstable_mockModule('../../lib/executeQuery.js', () => ({
-    executeQuery: mockExecuteQuery,
-    parseTarget: jest.fn(),
-}));
-const mockExit = jest.spyOn(process, 'exit').mockImplementation((() => {
-    throw new Error('process.exit called');
-}));
-const mockConsoleLog = jest.spyOn(console, 'log').mockImplementation(() => { });
-const { createModelsCommand } = await import('./index.js');
-describe('models command', () => {
-    beforeEach(() => {
-        jest.clearAllMocks();
-    });
-    it('creates command with correct structure', () => {
-        const command = createModelsCommand({});
-        expect(command).toBeInstanceOf(Command);
-        expect(command.name()).toBe('models');
-    });
-    it('lists models in text format', async () => {
-        const mockModels = {
-            items: [{ metadata: { name: 'gpt-4' } }, { metadata: { name: 'claude-3' } }],
-        };
-        mockExeca.mockResolvedValue({ stdout: JSON.stringify(mockModels) });
-        const command = createModelsCommand({});
-        await command.parseAsync(['node', 'test']);
-        expect(mockExeca).toHaveBeenCalledWith('kubectl', ['get', 'models', '-o', 'json'], { stdio: 'pipe' });
-        expect(mockConsoleLog).toHaveBeenCalledWith('gpt-4');
-        expect(mockConsoleLog).toHaveBeenCalledWith('claude-3');
-    });
-    it('lists models in json format', async () => {
-        const mockModels = {
-            items: [{ metadata: { name: 'gpt-4' } }],
-        };
-        mockExeca.mockResolvedValue({ stdout: JSON.stringify(mockModels) });
-        const command = createModelsCommand({});
-        await command.parseAsync(['node', 'test', '-o', 'json']);
-        expect(mockConsoleLog).toHaveBeenCalledWith(JSON.stringify(mockModels.items, null, 2));
-    });
-    it('shows info when no models', async () => {
-        mockExeca.mockResolvedValue({ stdout: JSON.stringify({ items: [] }) });
-        const command = createModelsCommand({});
-        await command.parseAsync(['node', 'test']);
-        expect(mockOutput.info).toHaveBeenCalledWith('No models found');
-    });
-    it('handles errors', async () => {
-        mockExeca.mockRejectedValue(new Error('kubectl failed'));
-        const command = createModelsCommand({});
-        await expect(command.parseAsync(['node', 'test'])).rejects.toThrow('process.exit called');
-        expect(mockOutput.error).toHaveBeenCalledWith('fetching models:', 'kubectl failed');
-        expect(mockExit).toHaveBeenCalledWith(1);
-    });
-    it('list subcommand works', async () => {
-        mockExeca.mockResolvedValue({ stdout: JSON.stringify({ items: [] }) });
-        const command = createModelsCommand({});
-        await command.parseAsync(['node', 'test', 'list']);
-        expect(mockExeca).toHaveBeenCalled();
-    });
-    it('create subcommand works', async () => {
-        const command = createModelsCommand({});
-        await command.parseAsync(['node', 'test', 'create', 'my-model']);
-        expect(mockCreateModel).toHaveBeenCalledWith('my-model', expect.objectContaining({}));
-    });
-    it('query subcommand works', async () => {
-        const command = createModelsCommand({});
-        await command.parseAsync([
-            'node',
-            'test',
-            'query',
-            'default',
-            'Hello world',
-        ]);
-        expect(mockExecuteQuery).toHaveBeenCalledWith({
-            targetType: 'model',
-            targetName: 'default',
-            message: 'Hello world',
-        });
-    });
-});

package/dist/commands/models/providers/azure.spec.d.ts

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