@agents-at-scale/ark 0.1.53 → 0.1.56

package/dist/commands/queries/delete.spec.js

@@ -1,74 +0,0 @@
-import { jest } from '@jest/globals';
-import output from '../../lib/output.js';
-const mockExeca = jest.fn();
-jest.unstable_mockModule('execa', () => ({
-    execa: mockExeca,
-}));
-const { createQueriesCommand } = await import('./index.js');
-const { deleteQuery, BOTH_NAME_AND_ALL_ERROR, MISSING_NAME_OR_ALL_ERROR } = await import('./delete.js');
-describe('queries delete command', () => {
-    beforeEach(() => {
-        jest.clearAllMocks();
-        console.log = jest.fn();
-        jest.spyOn(output, 'warning').mockImplementation(() => { });
-        jest.spyOn(output, 'error').mockImplementation(() => { });
-        jest.spyOn(process, 'exit').mockImplementation(() => undefined);
-    });
-    it('should delete a query by name', async () => {
-        mockExeca.mockResolvedValue({
-            stdout: '',
-        });
-        const command = createQueriesCommand({});
-        await command.parseAsync(['node', 'test', 'delete', 'query-1']);
-        expect(mockExeca).toHaveBeenCalledWith('kubectl', ['delete', 'queries', 'query-1'], { stdio: 'pipe' });
-        expect(output.warning).not.toHaveBeenCalled();
-        expect(process.exit).not.toHaveBeenCalled();
-    });
-    it('should delete all queries with --all flag', async () => {
-        mockExeca.mockResolvedValue({
-            stdout: '',
-        });
-        const command = createQueriesCommand({});
-        await command.parseAsync(['node', 'test', 'delete', '--all']);
-        expect(mockExeca).toHaveBeenCalledWith('kubectl', ['delete', 'queries', '--all'], { stdio: 'pipe' });
-        expect(output.warning).not.toHaveBeenCalled();
-        expect(process.exit).not.toHaveBeenCalled();
-    });
-});
-describe('deleteQuery function', () => {
-    beforeEach(() => {
-        jest.clearAllMocks();
-        jest.spyOn(output, 'error').mockImplementation(() => { });
-        jest.spyOn(process, 'exit').mockImplementation(() => undefined);
-    });
-    it('should throw error when neither name nor --all flag is provided', async () => {
-        await deleteQuery(undefined, {});
-        expect(output.error).toHaveBeenCalledWith(expect.anything(), expect.stringMatching(MISSING_NAME_OR_ALL_ERROR));
-        expect(process.exit).toHaveBeenCalledWith(1);
-    });
-    it('should throw error when both name and --all flag are provided', async () => {
-        await deleteQuery('my-query', { all: true });
-        expect(output.error).toHaveBeenCalledWith(expect.anything(), expect.stringMatching(BOTH_NAME_AND_ALL_ERROR));
-        expect(process.exit).toHaveBeenCalledWith(1);
-    });
-    it('should handle deletion errors gracefully', async () => {
-        mockExeca.mockRejectedValue(new Error('query not found'));
-        await deleteQuery('nonexistent-query', {});
-        expect(output.error).toHaveBeenCalledWith('deleting query:', 'query not found');
-        expect(process.exit).toHaveBeenCalledWith(1);
-    });
-    it('should call deleteResource with query name', async () => {
-        mockExeca.mockResolvedValue({
-            stdout: '',
-        });
-        await deleteQuery('my-query', {});
-        expect(mockExeca).toHaveBeenCalledWith('kubectl', ['delete', 'queries', 'my-query'], { stdio: 'pipe' });
-    });
-    it('should delete all queries when all option is true', async () => {
-        mockExeca.mockResolvedValue({
-            stdout: '',
-        });
-        await deleteQuery(undefined, { all: true });
-        expect(mockExeca).toHaveBeenCalledWith('kubectl', ['delete', 'queries', '--all'], { stdio: 'pipe' });
-    });
-});

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

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

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

@@ -1,167 +0,0 @@
-import { jest } from '@jest/globals';
-import output from '../../lib/output.js';
-const mockExeca = jest.fn();
-jest.unstable_mockModule('execa', () => ({
-    execa: mockExeca,
-}));
-const { createQueriesCommand } = await import('./index.js');
-describe('queries get command', () => {
-    beforeEach(() => {
-        jest.clearAllMocks();
-        console.log = jest.fn();
-        jest.spyOn(output, 'warning').mockImplementation(() => { });
-        jest.spyOn(output, 'error').mockImplementation(() => { });
-        jest.spyOn(process, 'exit').mockImplementation(() => undefined);
-    });
-    it('should get query with response in JSON format', async () => {
-        const mockQuery = {
-            metadata: {
-                name: 'test-query',
-            },
-            spec: {
-                input: 'test input',
-                target: { type: 'agent', name: 'test-agent' },
-            },
-            status: {
-                phase: 'done',
-                response: {
-                    content: 'This is the response',
-                },
-            },
-        };
-        mockExeca.mockResolvedValue({
-            stdout: JSON.stringify(mockQuery),
-        });
-        const command = createQueriesCommand({});
-        await command.parseAsync(['node', 'test', 'get', 'test-query']);
-        expect(console.log).toHaveBeenCalledWith(JSON.stringify(mockQuery, null, 2));
-        expect(mockExeca).toHaveBeenCalledWith('kubectl', ['get', 'queries', 'test-query', '-o', 'json'], { stdio: 'pipe' });
-    });
-    it('should get query with response flag in JSON format', async () => {
-        const mockQuery = {
-            metadata: {
-                name: 'test-query',
-            },
-            spec: {
-                input: 'test input',
-                target: { type: 'agent', name: 'test-agent' },
-            },
-            status: {
-                phase: 'done',
-                response: {
-                    content: 'This is the response content',
-                },
-            },
-        };
-        mockExeca.mockResolvedValue({
-            stdout: JSON.stringify(mockQuery),
-        });
-        const command = createQueriesCommand({});
-        await command.parseAsync([
-            'node',
-            'test',
-            'get',
-            'test-query',
-            '--response',
-        ]);
-        expect(console.log).toHaveBeenCalledWith(JSON.stringify(mockQuery.status.response, null, 2));
-        expect(mockExeca).toHaveBeenCalledWith('kubectl', ['get', 'queries', 'test-query', '-o', 'json'], { stdio: 'pipe' });
-    });
-    it('should get query with response flag in markdown format', async () => {
-        const mockQuery = {
-            metadata: {
-                name: 'test-query',
-            },
-            spec: {
-                input: 'test input',
-                target: { type: 'agent', name: 'test-agent' },
-            },
-            status: {
-                phase: 'done',
-                response: {
-                    content: '# Heading\n\nThis is markdown content',
-                },
-            },
-        };
-        mockExeca.mockResolvedValue({
-            stdout: JSON.stringify(mockQuery),
-        });
-        const command = createQueriesCommand({});
-        await command.parseAsync([
-            'node',
-            'test',
-            'get',
-            'test-query',
-            '--response',
-            '--output',
-            'markdown',
-        ]);
-        expect(console.log).toHaveBeenCalled();
-        expect(mockExeca).toHaveBeenCalledWith('kubectl', ['get', 'queries', 'test-query', '-o', 'json'], { stdio: 'pipe' });
-    });
-    it('should get query in markdown format without response flag', async () => {
-        const mockQuery = {
-            metadata: {
-                name: 'test-query',
-            },
-            spec: {
-                input: 'test input',
-                target: { type: 'agent', name: 'test-agent' },
-            },
-            status: {
-                phase: 'done',
-                response: {
-                    content: '# Response\n\nMarkdown response',
-                },
-            },
-        };
-        mockExeca.mockResolvedValue({
-            stdout: JSON.stringify(mockQuery),
-        });
-        const command = createQueriesCommand({});
-        await command.parseAsync([
-            'node',
-            'test',
-            'get',
-            'test-query',
-            '--output',
-            'markdown',
-        ]);
-        expect(console.log).toHaveBeenCalled();
-        expect(mockExeca).toHaveBeenCalledWith('kubectl', ['get', 'queries', 'test-query', '-o', 'json'], { stdio: 'pipe' });
-    });
-    it('should warn when query has no response with response flag', async () => {
-        const mockQuery = {
-            metadata: {
-                name: 'test-query',
-            },
-            spec: {
-                input: 'test input',
-                target: { type: 'agent', name: 'test-agent' },
-            },
-            status: {
-                phase: 'running',
-            },
-        };
-        mockExeca.mockResolvedValue({
-            stdout: JSON.stringify(mockQuery),
-        });
-        const command = createQueriesCommand({});
-        await command.parseAsync([
-            'node',
-            'test',
-            'get',
-            'test-query',
-            '--response',
-        ]);
-        expect(output.warning).toHaveBeenCalledWith('No response available');
-        expect(mockExeca).toHaveBeenCalledWith('kubectl', ['get', 'queries', 'test-query', '-o', 'json'], { stdio: 'pipe' });
-    });
-    it('should handle errors when getting query', async () => {
-        mockExeca.mockRejectedValue(new Error('Query not found'));
-        const command = createQueriesCommand({});
-        await command.parseAsync(['node', 'test', 'get', 'nonexistent-query']);
-        expect(output.error).toHaveBeenCalledWith('fetching query:', 'Query not found');
-        expect(process.exit).toHaveBeenCalled();
-    });
-});

package/dist/commands/queries/list.spec.d.ts

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

package/dist/commands/queries/list.spec.js

@@ -1,170 +0,0 @@
-import { jest } from '@jest/globals';
-import { UNSUPPORTED_OUTPUT_FORMAT_MESSAGE } from './validation.js';
-import output from '../../lib/output.js';
-const mockExeca = jest.fn();
-jest.unstable_mockModule('execa', () => ({
-    execa: mockExeca,
-}));
-const { createQueriesCommand } = await import('./index.js');
-describe('queries list command', () => {
-    beforeEach(() => {
-        jest.clearAllMocks();
-        console.log = jest.fn();
-        jest.spyOn(output, 'warning').mockImplementation(() => { });
-        jest.spyOn(output, 'error').mockImplementation(() => { });
-        jest.spyOn(process, 'exit').mockImplementation(() => undefined);
-    });
-    it('should list all queries in text format by default', async () => {
-        const mockQueries = [
-            {
-                metadata: {
-                    name: 'query-1',
-                    creationTimestamp: '2024-01-01T00:00:00Z',
-                },
-                status: {
-                    phase: 'done',
-                },
-            },
-            {
-                metadata: {
-                    name: 'query-2',
-                    creationTimestamp: '2024-01-02T00:00:00Z',
-                },
-                status: {
-                    phase: 'running',
-                },
-            },
-        ];
-        mockExeca.mockResolvedValue({
-            stdout: JSON.stringify({ items: mockQueries }),
-        });
-        const command = createQueriesCommand({});
-        await command.parseAsync(['node', 'test', 'list']);
-        expect(console.log).toHaveBeenCalledWith(expect.stringMatching(/NAME.*STATUS/));
-        expect(console.log).toHaveBeenCalledWith(expect.stringMatching(/query-1/));
-        expect(console.log).toHaveBeenCalledWith(expect.stringMatching(/query-2/));
-        expect(mockExeca).toHaveBeenCalledWith('kubectl', ['get', 'queries', '-o', 'json'], { stdio: 'pipe' });
-    });
-    it('should list all queries in JSON format', async () => {
-        const mockQueries = [
-            {
-                metadata: {
-                    name: 'query-1',
-                    creationTimestamp: '2024-01-01T00:00:00Z',
-                },
-            },
-            {
-                metadata: {
-                    name: 'query-2',
-                    creationTimestamp: '2024-01-02T00:00:00Z',
-                },
-            },
-        ];
-        mockExeca.mockResolvedValue({
-            stdout: JSON.stringify({ items: mockQueries }),
-        });
-        const command = createQueriesCommand({});
-        await command.parseAsync(['node', 'test', '--output', 'json']);
-        expect(console.log).toHaveBeenCalledWith(JSON.stringify(mockQueries, null, 2));
-        expect(mockExeca).toHaveBeenCalledWith('kubectl', ['get', 'queries', '-o', 'json'], { stdio: 'pipe' });
-    });
-    it('should support sorting by creation timestamp', async () => {
-        const mockQueries = [
-            {
-                metadata: {
-                    name: 'query-1',
-                    creationTimestamp: '2024-01-01T00:00:00Z',
-                },
-                status: {
-                    phase: 'done',
-                },
-            },
-            {
-                metadata: {
-                    name: 'query-2',
-                    creationTimestamp: '2024-01-02T00:00:00Z',
-                },
-                status: {
-                    phase: 'running',
-                },
-            },
-        ];
-        mockExeca.mockResolvedValue({
-            stdout: JSON.stringify({ items: mockQueries }),
-        });
-        const command = createQueriesCommand({});
-        await command.parseAsync([
-            'node',
-            'test',
-            '--sort-by',
-            '.metadata.creationTimestamp',
-        ]);
-        expect(console.log).toHaveBeenCalledWith(expect.stringMatching(/NAME.*STATUS/));
-        expect(console.log).toHaveBeenCalledWith(expect.stringMatching(/query-1/));
-        expect(console.log).toHaveBeenCalledWith(expect.stringMatching(/query-2/));
-        expect(mockExeca).toHaveBeenCalledWith('kubectl', ['get', 'queries', '--sort-by=.metadata.creationTimestamp', '-o', 'json'], { stdio: 'pipe' });
-    });
-    it('should display warning when no queries exist', async () => {
-        mockExeca.mockResolvedValue({
-            stdout: JSON.stringify({ items: [] }),
-        });
-        const command = createQueriesCommand({});
-        await command.parseAsync(['node', 'test', 'list']);
-        expect(output.warning).toHaveBeenCalledWith('no queries available');
-        expect(mockExeca).toHaveBeenCalledWith('kubectl', ['get', 'queries', '-o', 'json'], { stdio: 'pipe' });
-    });
-    it('should handle errors when listing queries', async () => {
-        mockExeca.mockRejectedValue(new Error('kubectl connection failed'));
-        const command = createQueriesCommand({});
-        await command.parseAsync(['node', 'test', 'list']);
-        expect(output.error).toHaveBeenCalled();
-        expect(process.exit).toHaveBeenCalled();
-    });
-    it('should handle invalid output format gracefully', async () => {
-        const mockQueries = [
-            {
-                metadata: {
-                    name: 'query-1',
-                    creationTimestamp: '2024-01-01T00:00:00Z',
-                },
-                status: {
-                    phase: 'done',
-                },
-            },
-        ];
-        mockExeca.mockResolvedValue({
-            stdout: JSON.stringify({ items: mockQueries }),
-        });
-        const command = createQueriesCommand({});
-        await command.parseAsync(['node', 'test', '--output', 'xml']);
-        expect(output.error).toHaveBeenCalledWith(expect.anything(), expect.stringMatching(UNSUPPORTED_OUTPUT_FORMAT_MESSAGE));
-        expect(mockExeca).not.toHaveBeenCalled();
-        expect(console.log).not.toHaveBeenCalledWith(expect.stringMatching(/query-1/));
-        expect(process.exit).toHaveBeenCalled();
-    });
-    it('should list many queries without truncation', async () => {
-        // Create 100 mock queries
-        const mockQueries = Array.from({ length: 100 }, (_, i) => ({
-            metadata: {
-                name: `query-${i + 1}`,
-                creationTimestamp: new Date(2024, 0, i + 1).toISOString(),
-            },
-            status: {
-                phase: i % 3 === 0 ? 'done' : i % 2 === 0 ? 'running' : 'initializing',
-            },
-        }));
-        mockExeca.mockResolvedValue({
-            stdout: JSON.stringify({ items: mockQueries }),
-        });
-        const command = createQueriesCommand({});
-        await command.parseAsync(['node', 'test', 'list']);
-        // Check for header and separator
-        expect(console.log).toHaveBeenCalledWith(expect.stringMatching(/NAME.*STATUS/));
-        // Verify all queries are logged
-        for (let i = 1; i <= 100; i++) {
-            expect(console.log).toHaveBeenCalledWith(expect.stringMatching(new RegExp(`query-${i}`)));
-        }
-        // Verify console.log was called: header + 100 queries
-        expect(console.log).toHaveBeenCalledTimes(101);
-    });
-});

package/dist/commands/queries/validation.spec.d.ts

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

package/dist/commands/queries/validation.spec.js

@@ -1,27 +0,0 @@
-import { jest } from '@jest/globals';
-import { InvalidArgumentError } from 'commander';
-import { assertSupportedOutputFormat, UNSUPPORTED_OUTPUT_FORMAT_MESSAGE, } from './validation.js';
-jest.spyOn(console, 'error').mockImplementation(() => { });
-describe('queries validation', () => {
-    describe('assertSupportedOutputFormat', () => {
-        it('should not throw for supported formats', () => {
-            expect(() => assertSupportedOutputFormat('json')).not.toThrow();
-            expect(() => assertSupportedOutputFormat('text')).not.toThrow();
-        });
-        it('should not throw when format is undefined', () => {
-            expect(() => assertSupportedOutputFormat(undefined)).not.toThrow();
-        });
-        it('should throw InvalidArgumentError for unsupported format', () => {
-            expect(() => assertSupportedOutputFormat('xml')).toThrow(InvalidArgumentError);
-        });
-        it('should include format and supported formats in error message', () => {
-            expect(() => assertSupportedOutputFormat('xml')).toThrow(UNSUPPORTED_OUTPUT_FORMAT_MESSAGE);
-        });
-        it('should work with various invalid formats', () => {
-            const invalidFormats = ['yaml', 'csv', 'html', 'pdf'];
-            for (const format of invalidFormats) {
-                expect(() => assertSupportedOutputFormat(format)).toThrow(InvalidArgumentError);
-            }
-        });
-    });
-});

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

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

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

@@ -1,104 +0,0 @@
-import { jest } from '@jest/globals';
-import { Command } from 'commander';
-const mockExecuteQuery = jest.fn();
-const mockParseTarget = jest.fn();
-jest.unstable_mockModule('../../lib/executeQuery.js', () => ({
-    executeQuery: mockExecuteQuery,
-    parseTarget: mockParseTarget,
-}));
-const mockOutput = {
-    error: jest.fn(),
-};
-jest.unstable_mockModule('../../lib/output.js', () => ({
-    default: mockOutput,
-}));
-const mockExit = jest.spyOn(process, 'exit').mockImplementation((() => {
-    throw new Error('process.exit called');
-}));
-const mockConsoleError = jest
-    .spyOn(console, 'error')
-    .mockImplementation(() => { });
-const { createQueryCommand } = await import('./index.js');
-describe('createQueryCommand', () => {
-    beforeEach(() => {
-        jest.clearAllMocks();
-    });
-    it('should create a query command', () => {
-        const command = createQueryCommand({});
-        expect(command).toBeInstanceOf(Command);
-        expect(command.name()).toBe('query');
-        expect(command.description()).toBe('Execute a single query against a model or agent');
-    });
-    it('should parse and execute query with valid target', async () => {
-        mockParseTarget.mockReturnValue({
-            type: 'model',
-            name: 'default',
-        });
-        mockExecuteQuery.mockResolvedValue(undefined);
-        const command = createQueryCommand({});
-        await command.parseAsync(['node', 'test', 'model/default', 'Hello world']);
-        expect(mockParseTarget).toHaveBeenCalledWith('model/default');
-        expect(mockExecuteQuery).toHaveBeenCalledWith({
-            targetType: 'model',
-            targetName: 'default',
-            message: 'Hello world',
-            outputFormat: undefined,
-        });
-    });
-    it('should pass output format option to executeQuery', async () => {
-        mockParseTarget.mockReturnValue({
-            type: 'model',
-            name: 'default',
-        });
-        mockExecuteQuery.mockResolvedValue(undefined);
-        const command = createQueryCommand({});
-        await command.parseAsync([
-            'node',
-            'test',
-            'model/default',
-            'Hello world',
-            '-o',
-            'json',
-        ]);
-        expect(mockParseTarget).toHaveBeenCalledWith('model/default');
-        expect(mockExecuteQuery).toHaveBeenCalledWith({
-            targetType: 'model',
-            targetName: 'default',
-            message: 'Hello world',
-            outputFormat: 'json',
-        });
-    });
-    it('should pass session-id option to executeQuery', async () => {
-        mockParseTarget.mockReturnValue({
-            type: 'agent',
-            name: 'test-agent',
-        });
-        mockExecuteQuery.mockResolvedValue(undefined);
-        const command = createQueryCommand({});
-        await command.parseAsync([
-            'node',
-            'test',
-            'agent/test-agent',
-            'Hello world',
-            '--session-id',
-            'my-session-123',
-        ]);
-        expect(mockParseTarget).toHaveBeenCalledWith('agent/test-agent');
-        expect(mockExecuteQuery).toHaveBeenCalledWith({
-            targetType: 'agent',
-            targetName: 'test-agent',
-            message: 'Hello world',
-            outputFormat: undefined,
-            sessionId: 'my-session-123',
-        });
-    });
-    it('should error on invalid target format', async () => {
-        mockParseTarget.mockReturnValue(null);
-        const command = createQueryCommand({});
-        await expect(command.parseAsync(['node', 'test', 'invalid-target', 'Hello'])).rejects.toThrow('process.exit called');
-        expect(mockParseTarget).toHaveBeenCalledWith('invalid-target');
-        expect(mockExecuteQuery).not.toHaveBeenCalled();
-        expect(mockConsoleError).toHaveBeenCalledWith(expect.stringContaining('Invalid target format'));
-        expect(mockExit).toHaveBeenCalledWith(1);
-    });
-});

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

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