@agents-at-scale/ark 0.1.42 → 0.1.43

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

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

@@ -0,0 +1,2 @@
+export declare const UNSUPPORTED_OUTPUT_FORMAT_MESSAGE = "unsupported \"output\" format";
+export declare function assertSupportedOutputFormat(format: string | undefined): void;

package/dist/commands/queries/validation.js

@@ -0,0 +1,10 @@
+import { InvalidArgumentError } from 'commander';
+const SUPPORTED_OUTPUT_FORMATS = ['json', 'text'];
+export const UNSUPPORTED_OUTPUT_FORMAT_MESSAGE = `unsupported "output" format`;
+const VALID_OUTPUT_FORMATS_MESSAGE = `valid formats are: ${SUPPORTED_OUTPUT_FORMATS.join(', ')}`;
+export function assertSupportedOutputFormat(format) {
+    if (format && !SUPPORTED_OUTPUT_FORMATS.includes(format)) {
+        const message = `${UNSUPPORTED_OUTPUT_FORMAT_MESSAGE}: "${format}". ${VALID_OUTPUT_FORMATS_MESSAGE}`;
+        throw new InvalidArgumentError(message);
+    }
+}

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

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

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

@@ -0,0 +1,27 @@
+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/uninstall/index.js

@@ -5,6 +5,7 @@ import inquirer from 'inquirer';
 import { showNoClusterError } from '../../lib/startup.js';
 import output from '../../lib/output.js';
 import { getInstallableServices } from '../../arkServices.js';
+import { isMarketplaceService, extractMarketplaceServiceName, getMarketplaceService, getAllMarketplaceServices, } from '../../marketplaceServices.js';
 async function uninstallService(service, verbose = false) {
     const helmArgs = ['uninstall', service.helmReleaseName, '--ignore-not-found'];
     // Only add namespace flag if service has explicit namespace
@@ -25,6 +26,32 @@ async function uninstallArk(config, serviceName, options = {}) {
     console.log(); // Add blank line after cluster info
     // If a specific service is requested, uninstall only that service
     if (serviceName) {
+        // Check if it's a marketplace service
+        if (isMarketplaceService(serviceName)) {
+            const marketplaceServiceName = extractMarketplaceServiceName(serviceName);
+            const service = getMarketplaceService(marketplaceServiceName);
+            if (!service) {
+                output.error(`marketplace service '${marketplaceServiceName}' not found`);
+                output.info('available marketplace services:');
+                const marketplaceServices = getAllMarketplaceServices();
+                for (const serviceName of Object.keys(marketplaceServices)) {
+                    output.info(`  marketplace/services/${serviceName}`);
+                }
+                process.exit(1);
+            }
+            output.info(`uninstalling marketplace service ${service.name}...`);
+            try {
+                await uninstallService(service, options.verbose);
+                output.success(`${service.name} uninstalled successfully`);
+            }
+            catch (error) {
+                output.error(`failed to uninstall ${service.name}`);
+                console.error(error);
+                process.exit(1);
+            }
+            return;
+        }
+        // Core ARK service
         const services = getInstallableServices();
         const service = Object.values(services).find((s) => s.name === serviceName);
         if (!service) {

package/dist/components/ChatUI.js

@@ -18,12 +18,12 @@ const generateMessageId = () => {
 // Configure marked with terminal renderer for markdown output
 const configureMarkdown = () => {
     marked.setOptions({
-        // @ts-expect-error - TerminalRenderer types are incomplete
+        // @ts-ignore - TerminalRenderer types are incomplete
         renderer: new TerminalRenderer({
             showSectionPrefix: false,
             width: 80,
             reflowText: true,
-            // @ts-expect-error - preserveNewlines exists but not in types
+            // @ts-ignore - preserveNewlines exists but not in types
             preserveNewlines: true,
         }),
     });

package/dist/index.js

@@ -16,6 +16,7 @@ import { createDocsCommand } from './commands/docs/index.js';
 import { createEvaluationCommand } from './commands/evaluation/index.js';
 import { createGenerateCommand } from './commands/generate/index.js';
 import { createInstallCommand } from './commands/install/index.js';
+import { createMarketplaceCommand } from './commands/marketplace/index.js';
 import { createMemoryCommand } from './commands/memory/index.js';
 import { createModelsCommand } from './commands/models/index.js';
 import { createQueryCommand } from './commands/query/index.js';
@@ -49,6 +50,7 @@ async function main() {
     program.addCommand(createEvaluationCommand(config));
     program.addCommand(createGenerateCommand(config));
     program.addCommand(createInstallCommand(config));
+    program.addCommand(createMarketplaceCommand(config));
     program.addCommand(createMemoryCommand(config));
     program.addCommand(createModelsCommand(config));
     program.addCommand(createQueryCommand(config));

package/dist/lib/arkApiClient.js

@@ -146,6 +146,8 @@ export class ArkApiClient {
         }));
     }
     async *createChatCompletionStream(params) {
+        // Errors from OpenAI SDK will automatically propagate with proper error messages
+        // and kill the CLI, so no try/catch needed here
         const stream = await this.openai.chat.completions.create({
             ...params,
             stream: true,

package/dist/lib/executeQuery.d.ts

@@ -11,10 +11,6 @@ export interface QueryOptions {
     verbose?: boolean;
     outputFormat?: string;
 }
-/**
- * Execute a query against any ARK target (model, agent, team)
- * This is the shared implementation used by all query commands
- */
 export declare function executeQuery(options: QueryOptions): Promise<void>;
 /**
  * Parse a target string like "model/default" or "agent/weather"

package/dist/lib/executeQuery.js

@@ -4,24 +4,91 @@
 import { execa } from 'execa';
 import ora from 'ora';
 import chalk from 'chalk';
-import output from './output.js';
 import { ExitCodes } from './errors.js';
-import { parseDuration } from './duration.js';
-import { getResource } from './kubectl.js';
-/**
- * Execute a query against any ARK target (model, agent, team)
- * This is the shared implementation used by all query commands
- */
+import { ArkApiProxy } from './arkApiProxy.js';
+import { ChatClient } from './chatClient.js';
 export async function executeQuery(options) {
-    const spinner = options.outputFormat
-        ? null
-        : ora('Creating query...').start();
-    const queryTimeoutMs = options.timeout
-        ? parseDuration(options.timeout)
-        : parseDuration('5m');
-    const watchTimeoutMs = options.watchTimeout
-        ? parseDuration(options.watchTimeout)
-        : queryTimeoutMs + 60000;
+    if (options.outputFormat) {
+        return executeQueryWithFormat(options);
+    }
+    let arkApiProxy;
+    const spinner = ora('Connecting to Ark API...').start();
+    try {
+        arkApiProxy = new ArkApiProxy();
+        const arkApiClient = await arkApiProxy.start();
+        const chatClient = new ChatClient(arkApiClient);
+        spinner.text = 'Executing query...';
+        const targetId = `${options.targetType}/${options.targetName}`;
+        const messages = [{ role: 'user', content: options.message }];
+        const state = {
+            toolCalls: new Map(),
+            content: '',
+        };
+        let lastAgentName;
+        let headerShown = false;
+        let firstOutput = true;
+        await chatClient.sendMessage(targetId, messages, { streamingEnabled: true }, (chunk, toolCalls, arkMetadata) => {
+            if (firstOutput) {
+                spinner.stop();
+                firstOutput = false;
+            }
+            const agentName = arkMetadata?.agent || arkMetadata?.team;
+            if (agentName && agentName !== lastAgentName) {
+                if (lastAgentName) {
+                    if (state.content) {
+                        process.stdout.write('\n');
+                    }
+                    process.stdout.write('\n');
+                }
+                const prefix = arkMetadata?.team ? '◆' : '●';
+                const color = arkMetadata?.team ? 'green' : 'cyan';
+                process.stdout.write(chalk[color](`${prefix} ${agentName}\n`));
+                lastAgentName = agentName;
+                state.content = '';
+                state.toolCalls.clear();
+                headerShown = true;
+            }
+            if (toolCalls && toolCalls.length > 0) {
+                for (const toolCall of toolCalls) {
+                    if (!state.toolCalls.has(toolCall.id)) {
+                        state.toolCalls.set(toolCall.id, toolCall);
+                        if (state.content) {
+                            process.stdout.write('\n');
+                        }
+                        process.stdout.write(chalk.magenta(`🔧 ${toolCall.function.name}\n`));
+                    }
+                }
+            }
+            if (chunk) {
+                if (state.toolCalls.size > 0 && !state.content) {
+                    process.stdout.write('\n');
+                }
+                process.stdout.write(chunk);
+                state.content += chunk;
+            }
+        });
+        if (spinner.isSpinning) {
+            spinner.stop();
+        }
+        if ((state.content || state.toolCalls.size > 0) && headerShown) {
+            process.stdout.write('\n');
+        }
+        if (arkApiProxy) {
+            arkApiProxy.stop();
+        }
+    }
+    catch (error) {
+        if (spinner.isSpinning) {
+            spinner.stop();
+        }
+        if (arkApiProxy) {
+            arkApiProxy.stop();
+        }
+        console.error(chalk.red(error instanceof Error ? error.message : 'Unknown error'));
+        process.exit(ExitCodes.CliError);
+    }
+}
+async function executeQueryWithFormat(options) {
     const timestamp = Date.now();
     const queryName = `cli-query-${timestamp}`;
     const queryManifest = {
@@ -42,104 +109,31 @@ export async function executeQuery(options) {
         },
     };
     try {
-        // Apply the query
-        if (spinner)
-            spinner.text = 'Submitting query...';
         await execa('kubectl', ['apply', '-f', '-'], {
             input: JSON.stringify(queryManifest),
             stdio: ['pipe', 'pipe', 'pipe'],
         });
-        // Watch for query completion using kubectl wait
-        if (spinner)
-            spinner.text = 'Waiting for query completion...';
-        try {
-            await execa('kubectl', [
-                'wait',
-                '--for=condition=Completed',
-                `query/${queryName}`,
-                `--timeout=${Math.floor(watchTimeoutMs / 1000)}s`,
-            ], { timeout: watchTimeoutMs });
-        }
-        catch (error) {
-            if (spinner)
-                spinner.stop();
-            // Check if it's a timeout or other error
-            if (error instanceof Error &&
-                error.message.includes('timed out waiting')) {
-                console.error(chalk.red(`Query did not complete within ${options.watchTimeout ?? `${Math.floor(watchTimeoutMs / 1000)}s`}`));
-                process.exit(ExitCodes.Timeout);
-            }
-            // For other errors, fetch the query to check status
-        }
-        if (spinner)
-            spinner.stop();
-        // If output format is specified, output the resource and return
-        if (options.outputFormat) {
-            try {
-                if (options.outputFormat === 'name') {
-                    console.log(queryName);
-                }
-                else if (options.outputFormat === 'json' ||
-                    options.outputFormat === 'yaml') {
-                    const { stdout } = await execa('kubectl', ['get', 'query', queryName, '-o', options.outputFormat], { stdio: 'pipe' });
-                    console.log(stdout);
-                }
-                else {
-                    console.error(chalk.red(`Invalid output format: ${options.outputFormat}. Use: yaml, json, or name`));
-                    process.exit(ExitCodes.CliError);
-                }
-                return;
-            }
-            catch (error) {
-                console.error(chalk.red(error instanceof Error
-                    ? error.message
-                    : 'Failed to fetch query resource'));
-                process.exit(ExitCodes.CliError);
-            }
+        const timeoutSeconds = 300;
+        await execa('kubectl', [
+            'wait',
+            '--for=condition=Completed',
+            `query/${queryName}`,
+            `--timeout=${timeoutSeconds}s`,
+        ], { timeout: timeoutSeconds * 1000 });
+        if (options.outputFormat === 'name') {
+            console.log(queryName);
         }
-        // Fetch final query state
-        try {
-            const query = await getResource('queries', queryName);
-            const phase = query.status?.phase;
-            // Check if query completed successfully or with error
-            if (phase === 'done') {
-                // Extract and display the response from responses array
-                if (query.status?.responses && query.status.responses.length > 0) {
-                    const response = query.status.responses[0];
-                    console.log(response.content || response);
-                }
-                else {
-                    output.warning('No response received');
-                }
-            }
-            else if (phase === 'error') {
-                const response = query.status?.responses?.[0];
-                console.error(chalk.red(response?.content || 'Query failed with unknown error'));
-                process.exit(ExitCodes.OperationError);
-            }
-            else if (phase === 'canceled') {
-                if (spinner) {
-                    spinner.warn('Query canceled');
-                }
-                else {
-                    output.warning('Query canceled');
-                }
-                if (query.status?.message) {
-                    output.warning(query.status.message);
-                }
-                process.exit(ExitCodes.OperationError);
-            }
+        else if (options.outputFormat === 'json' ||
+            options.outputFormat === 'yaml') {
+            const { stdout } = await execa('kubectl', ['get', 'query', queryName, '-o', options.outputFormat], { stdio: 'pipe' });
+            console.log(stdout);
         }
-        catch (error) {
-            console.error(chalk.red(error instanceof Error
-                ? error.message
-                : 'Failed to fetch query result'));
+        else {
+            console.error(chalk.red(`Invalid output format: ${options.outputFormat}. Use: yaml, json, or name`));
             process.exit(ExitCodes.CliError);
         }
     }
     catch (error) {
-        if (spinner)
-            spinner.stop();
         console.error(chalk.red(error instanceof Error ? error.message : 'Unknown error'));
         process.exit(ExitCodes.CliError);
     }