@agents-at-scale/ark 0.1.41 → 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/query/index.js

@@ -8,7 +8,8 @@ export function createQueryCommand(_) {
         .description('Execute a single query against a model or agent')
         .argument('<target>', 'Query target (e.g., model/default, agent/my-agent)')
         .argument('<message>', 'Message to send')
-        .action(async (target, message) => {
+        .option('-o, --output <format>', 'Output format: yaml, json, or name (prints only resource name)')
+        .action(async (target, message, options) => {
         const parsed = parseTarget(target);
         if (!parsed) {
             console.error(chalk.red('Invalid target format. Use: model/name or agent/name etc'));
@@ -18,6 +19,7 @@ export function createQueryCommand(_) {
             targetType: parsed.type,
             targetName: parsed.name,
             message,
+            outputFormat: options.output,
         });
     });
     return queryCommand;

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

@@ -42,6 +42,30 @@ describe('createQueryCommand', () => {
             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 error on invalid target format', async () => {

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

package/dist/index.js

@@ -13,10 +13,14 @@ import { createClusterCommand } from './commands/cluster/index.js';
 import { createCompletionCommand } from './commands/completion/index.js';
 import { createDashboardCommand } from './commands/dashboard/index.js';
 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';
+import { createQueriesCommand } from './commands/queries/index.js';
 import { createUninstallCommand } from './commands/uninstall/index.js';
 import { createStatusCommand } from './commands/status/index.js';
 import { createConfigCommand } from './commands/config/index.js';
@@ -43,10 +47,14 @@ async function main() {
     program.addCommand(createCompletionCommand(config));
     program.addCommand(createDashboardCommand(config));
     program.addCommand(createDocsCommand(config));
+    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));
+    program.addCommand(createQueriesCommand(config));
     program.addCommand(createUninstallCommand(config));
     program.addCommand(createStatusCommand());
     program.addCommand(createConfigCommand(config));

package/dist/lib/arkApiClient.d.ts

@@ -47,6 +47,10 @@ export declare class ArkApiClient {
     getModels(): Promise<Model[]>;
     getTools(): Promise<Tool[]>;
     getTeams(): Promise<Team[]>;
+    getSessions(): Promise<any[]>;
+    deleteSession(sessionId: string): Promise<any>;
+    deleteQueryMessages(sessionId: string, queryId: string): Promise<any>;
+    deleteAllSessions(): Promise<any>;
     createChatCompletion(params: OpenAI.Chat.Completions.ChatCompletionCreateParams): Promise<OpenAI.Chat.Completions.ChatCompletion>;
     createChatCompletionStream(params: OpenAI.Chat.Completions.ChatCompletionCreateParams): AsyncIterable<OpenAI.Chat.Completions.ChatCompletionChunk>;
 }

package/dist/lib/arkApiClient.js

@@ -84,6 +84,61 @@ export class ArkApiClient {
             throw new Error(`Failed to get teams: ${error instanceof Error ? error.message : 'Unknown error'}`);
         }
     }
+    async getSessions() {
+        try {
+            const response = await fetch(`${this.baseUrl}/v1/sessions`);
+            if (!response.ok) {
+                throw new Error(`HTTP error! status: ${response.status}`);
+            }
+            const data = (await response.json());
+            return data.items || [];
+        }
+        catch (error) {
+            throw new Error(`Failed to get sessions: ${error instanceof Error ? error.message : 'Unknown error'}`);
+        }
+    }
+    async deleteSession(sessionId) {
+        try {
+            const response = await fetch(`${this.baseUrl}/v1/sessions/${sessionId}`, {
+                method: 'DELETE',
+            });
+            if (!response.ok) {
+                throw new Error(`HTTP error! status: ${response.status}`);
+            }
+            return await response.json();
+        }
+        catch (error) {
+            throw new Error(`Failed to delete session: ${error instanceof Error ? error.message : 'Unknown error'}`);
+        }
+    }
+    async deleteQueryMessages(sessionId, queryId) {
+        try {
+            const response = await fetch(`${this.baseUrl}/v1/sessions/${sessionId}/queries/${queryId}/messages`, {
+                method: 'DELETE',
+            });
+            if (!response.ok) {
+                throw new Error(`HTTP error! status: ${response.status}`);
+            }
+            return await response.json();
+        }
+        catch (error) {
+            throw new Error(`Failed to delete query messages: ${error instanceof Error ? error.message : 'Unknown error'}`);
+        }
+    }
+    async deleteAllSessions() {
+        try {
+            const response = await fetch(`${this.baseUrl}/v1/sessions`, {
+                method: 'DELETE',
+            });
+            if (!response.ok) {
+                throw new Error(`HTTP error! status: ${response.status}`);
+            }
+            return await response.json();
+        }
+        catch (error) {
+            throw new Error(`Failed to delete all sessions: ${error instanceof Error ? error.message : 'Unknown error'}`);
+        }
+    }
     async createChatCompletion(params) {
         return (await this.openai.chat.completions.create({
             ...params,
@@ -91,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/errors.d.ts

@@ -6,6 +6,7 @@ export declare const ExitCodes: {
     readonly CliError: 1;
     readonly OperationError: 2;
     readonly Timeout: 3;
+    readonly EvaluationFailed: 4;
 };
 export declare enum ErrorCode {
     INVALID_INPUT = "INVALID_INPUT",

package/dist/lib/errors.js

@@ -8,6 +8,7 @@ export const ExitCodes = {
     CliError: 1,
     OperationError: 2,
     Timeout: 3,
+    EvaluationFailed: 4,
 };
 export var ErrorCode;
 (function (ErrorCode) {

package/dist/lib/executeEvaluation.d.ts

@@ -0,0 +1,16 @@
+export interface DirectEvaluationOptions {
+    evaluatorName: string;
+    input: string;
+    output: string;
+    timeout?: string;
+    watchTimeout?: string;
+}
+export interface QueryEvaluationOptions {
+    evaluatorName: string;
+    queryName: string;
+    responseTarget?: string;
+    timeout?: string;
+    watchTimeout?: string;
+}
+export declare function executeDirectEvaluation(options: DirectEvaluationOptions): Promise<void>;
+export declare function executeQueryEvaluation(options: QueryEvaluationOptions): Promise<void>;

package/dist/lib/executeEvaluation.js

@@ -0,0 +1,155 @@
+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';
+async function waitForEvaluationAndDisplayResults(evaluationName, watchTimeoutMs, watchTimeoutDisplay) {
+    const spinner = ora('Waiting for evaluation completion...').start();
+    try {
+        await execa('kubectl', [
+            'wait',
+            '--for=condition=Completed',
+            `evaluation/${evaluationName}`,
+            `--timeout=${Math.floor(watchTimeoutMs / 1000)}s`,
+        ], { timeout: watchTimeoutMs });
+    }
+    catch (error) {
+        spinner.stop();
+        if (error instanceof Error && error.message.includes('timed out waiting')) {
+            console.error(chalk.red(`Evaluation did not complete within ${watchTimeoutDisplay}`));
+            process.exit(ExitCodes.Timeout);
+        }
+        throw error;
+    }
+    spinner.stop();
+    const { stdout } = await execa('kubectl', ['get', 'evaluation', evaluationName, '-o', 'json'], { stdio: 'pipe' });
+    const evaluation = JSON.parse(stdout);
+    const status = evaluation.status;
+    if (status?.phase === 'done') {
+        console.log(chalk.green('\nEvaluation completed successfully:'));
+        if (status.score !== undefined) {
+            console.log(`Score: ${status.score}`);
+        }
+        if (status.passed !== undefined) {
+            console.log(`Result: ${status.passed ? chalk.green('PASSED') : chalk.red('FAILED')}`);
+        }
+        if (status.message) {
+            console.log(`Message: ${status.message}`);
+        }
+    }
+    else if (status?.phase === 'error') {
+        console.error(chalk.red(status.message || 'Evaluation failed with unknown error'));
+        process.exit(ExitCodes.OperationError);
+    }
+    else {
+        output.warning(`Unexpected evaluation phase: ${status?.phase}`);
+    }
+}
+export async function executeDirectEvaluation(options) {
+    const spinner = ora('Creating evaluation...').start();
+    const queryTimeoutMs = options.timeout
+        ? parseDuration(options.timeout)
+        : parseDuration('5m');
+    const watchTimeoutMs = options.watchTimeout
+        ? parseDuration(options.watchTimeout)
+        : queryTimeoutMs + 60000;
+    const timestamp = Date.now();
+    const evaluationName = `cli-eval-${timestamp}`;
+    const evaluationManifest = {
+        apiVersion: 'ark.mckinsey.com/v1alpha1',
+        kind: 'Evaluation',
+        metadata: {
+            name: evaluationName,
+        },
+        spec: {
+            type: 'direct',
+            evaluator: {
+                name: options.evaluatorName,
+            },
+            config: {
+                input: options.input,
+                output: options.output,
+            },
+            ...(options.timeout && { timeout: options.timeout }),
+            ttl: '1h',
+        },
+    };
+    try {
+        spinner.text = 'Submitting evaluation...';
+        await execa('kubectl', ['apply', '-f', '-'], {
+            input: JSON.stringify(evaluationManifest),
+            stdio: ['pipe', 'pipe', 'pipe'],
+        });
+        spinner.stop();
+        const watchTimeoutDisplay = options.watchTimeout ?? `${Math.floor(watchTimeoutMs / 1000)}s`;
+        await waitForEvaluationAndDisplayResults(evaluationName, watchTimeoutMs, watchTimeoutDisplay);
+    }
+    catch (error) {
+        spinner.stop();
+        console.error(chalk.red(error instanceof Error ? error.message : 'Unknown error'));
+        process.exit(ExitCodes.CliError);
+    }
+}
+export async function executeQueryEvaluation(options) {
+    const spinner = ora('Creating evaluation...').start();
+    const queryTimeoutMs = options.timeout
+        ? parseDuration(options.timeout)
+        : parseDuration('5m');
+    const watchTimeoutMs = options.watchTimeout
+        ? parseDuration(options.watchTimeout)
+        : queryTimeoutMs + 60000;
+    const timestamp = Date.now();
+    const evaluationName = `cli-eval-${timestamp}`;
+    let responseTarget;
+    if (options.responseTarget) {
+        const parts = options.responseTarget.split(':');
+        if (parts.length === 2) {
+            responseTarget = {
+                type: parts[0],
+                name: parts[1],
+            };
+        }
+        else {
+            spinner.stop();
+            console.error(chalk.red('Invalid response-target format. Use: type:name (e.g., agent:my-agent)'));
+            process.exit(ExitCodes.CliError);
+        }
+    }
+    const evaluationManifest = {
+        apiVersion: 'ark.mckinsey.com/v1alpha1',
+        kind: 'Evaluation',
+        metadata: {
+            name: evaluationName,
+        },
+        spec: {
+            type: 'query',
+            evaluator: {
+                name: options.evaluatorName,
+            },
+            config: {
+                queryRef: {
+                    name: options.queryName,
+                },
+                ...(responseTarget && { responseTarget }),
+            },
+            ...(options.timeout && { timeout: options.timeout }),
+            ttl: '1h',
+        },
+    };
+    try {
+        spinner.text = 'Submitting evaluation...';
+        await execa('kubectl', ['apply', '-f', '-'], {
+            input: JSON.stringify(evaluationManifest),
+            stdio: ['pipe', 'pipe', 'pipe'],
+        });
+        spinner.stop();
+        const watchTimeoutDisplay = options.watchTimeout ?? `${Math.floor(watchTimeoutMs / 1000)}s`;
+        await waitForEvaluationAndDisplayResults(evaluationName, watchTimeoutMs, watchTimeoutDisplay);
+    }
+    catch (error) {
+        spinner.stop();
+        console.error(chalk.red(error instanceof Error ? error.message : 'Unknown error'));
+        process.exit(ExitCodes.CliError);
+    }
+}

package/dist/lib/executeQuery.d.ts

@@ -9,11 +9,8 @@ export interface QueryOptions {
     timeout?: string;
     watchTimeout?: string;
     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"