@agents-at-scale/ark 0.1.41 → 0.1.43

package/dist/arkServices.js

@@ -107,15 +107,6 @@ const defaultArkServices = {
         k8sDevDeploymentName: 'ark-dashboard-devspace',
         k8sPortForwardLocalPort: 3274,
     },
-    'ark-api-a2a': {
-        name: 'ark-api-a2a',
-        helmReleaseName: 'ark-api-a2a',
-        description: 'Ark API agent-to-agent communication service',
-        enabled: false, // Disabled - not currently used
-        category: 'service',
-        // namespace: undefined - uses current context namespace
-        // Note: This service might be installed as part of ark-api or separately
-    },
     'ark-mcp': {
         name: 'ark-mcp',
         helmReleaseName: 'ark-mcp',

package/dist/commands/completion/index.js

@@ -28,7 +28,7 @@ _ark_completion() {
   
   case \${COMP_CWORD} in
     1)
-      opts="agents chat cluster completion config dashboard docs generate install models query routes status targets teams tools uninstall help"
+      opts="agents chat cluster completion config dashboard docs generate install marketplace models queries query routes status targets teams tools uninstall help"
       COMPREPLY=( $(compgen -W "\${opts}" -- \${cur}) )
       return 0
       ;;
@@ -79,6 +79,23 @@ _ark_completion() {
           COMPREPLY=( $(compgen -W "\${opts}" -- \${cur}) )
           return 0
           ;;
+        marketplace)
+          opts="list ls"
+          COMPREPLY=( $(compgen -W "\${opts}" -- \${cur}) )
+          return 0
+          ;;
+        install)
+          # Suggest marketplace services with marketplace/services/ prefix
+          opts="marketplace/services/phoenix marketplace/services/langfuse"
+          COMPREPLY=( $(compgen -W "\${opts}" -- \${cur}) )
+          return 0
+          ;;
+        uninstall)
+          # Suggest marketplace services with marketplace/services/ prefix
+          opts="marketplace/services/phoenix marketplace/services/langfuse"
+          COMPREPLY=( $(compgen -W "\${opts}" -- \${cur}) )
+          return 0
+          ;;
         chat)
           # Dynamically fetch available targets using ark targets list
           local targets
@@ -101,6 +118,11 @@ _ark_completion() {
           COMPREPLY=( $(compgen -W "\${targets}" -- \${cur}) )
           return 0
           ;;
+        queries)
+          opts="get delete resubmit"
+          COMPREPLY=( $(compgen -W "\${opts}" -- \${cur}) )
+          return 0
+          ;;
       esac
       ;;
   esac
@@ -137,7 +159,9 @@ _ark() {
         'docs[Open ARK documentation]' \\
         'generate[Generate ARK resources]' \\
         'install[Install ARK services]' \\
+        'marketplace[Manage marketplace services]' \\
         'models[List available models]' \\
+        'queries[Manage query resources]' \\
         'query[Execute a single query]' \\
         'routes[List available routes]' \\
         'status[Check system status]' \\
@@ -198,6 +222,21 @@ _ark() {
             'query[Generate a query]' \\
             'team[Generate a team]'
           ;;
+        marketplace)
+          _values 'marketplace commands' \\
+            'list[List available marketplace services]' \\
+            'ls[List available marketplace services]'
+          ;;
+        install)
+          _values 'services to install' \\
+            'marketplace/services/phoenix[Phoenix observability platform]' \\
+            'marketplace/services/langfuse[Langfuse LLM analytics]'
+          ;;
+        uninstall)
+          _values 'services to uninstall' \\
+            'marketplace/services/phoenix[Phoenix observability platform]' \\
+            'marketplace/services/langfuse[Langfuse LLM analytics]'
+          ;;
         chat)
           # Get available targets dynamically
           local -a targets
@@ -216,6 +255,12 @@ _ark() {
           fi
           _values 'available targets' \${targets[@]}
           ;;
+        queries)
+          _values 'queries commands' \\
+            'get[Get a specific query]' \\
+            'delete[Delete a query]' \\
+            'resubmit[Resubmit a query by clearing its status]'
+          ;;
       esac
       ;;
   esac

package/dist/commands/evaluation/index.d.ts

@@ -0,0 +1,3 @@
+import { Command } from 'commander';
+import type { ArkConfig } from '../../lib/config.js';
+export declare function createEvaluationCommand(_: ArkConfig): Command;

package/dist/commands/evaluation/index.js

@@ -0,0 +1,60 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import { executeDirectEvaluation, executeQueryEvaluation, } from '../../lib/executeEvaluation.js';
+import { readStdin } from '../../lib/stdin.js';
+export function createEvaluationCommand(_) {
+    const evaluationCommand = new Command('evaluation');
+    evaluationCommand
+        .description('Execute evaluations against evaluators')
+        .argument('<evaluator-name>', 'Name of the evaluator to use')
+        .argument('[query-name]', 'Name of the query to evaluate (for query-based evaluation)')
+        .option('--input <input>', 'Input text for direct evaluation')
+        .option('--output <output>', 'Output text for direct evaluation')
+        .option('--response-target <target>', 'Response target for query evaluation (e.g., agent:my-agent)')
+        .option('--timeout <timeout>', 'Evaluation timeout (e.g., "30s", "5m")')
+        .option('--watch-timeout <timeout>', 'CLI watch timeout')
+        .action(async (evaluatorName, queryName, options) => {
+        if (options.input && options.output) {
+            await executeDirectEvaluation({
+                evaluatorName,
+                input: options.input,
+                output: options.output,
+                timeout: options.timeout,
+                watchTimeout: options.watchTimeout,
+            });
+        }
+        else if (queryName) {
+            await executeQueryEvaluation({
+                evaluatorName,
+                queryName,
+                responseTarget: options.responseTarget,
+                timeout: options.timeout,
+                watchTimeout: options.watchTimeout,
+            });
+        }
+        else {
+            const stdinQueryName = await readStdin();
+            if (stdinQueryName) {
+                await executeQueryEvaluation({
+                    evaluatorName,
+                    queryName: stdinQueryName,
+                    responseTarget: options.responseTarget,
+                    timeout: options.timeout,
+                    watchTimeout: options.watchTimeout,
+                });
+            }
+            else {
+                console.error(chalk.red('Error: Must provide either:'));
+                console.error('  - --input and --output for direct evaluation');
+                console.error('  - <query-name> for query-based evaluation');
+                console.error('  - Pipe query name from stdin');
+                console.error('\nExamples:');
+                console.error('  ark evaluation my-evaluator --input "test" --output "result"');
+                console.error('  ark evaluation my-evaluator my-query');
+                console.error('  echo "my-query" | ark evaluation my-evaluator');
+                process.exit(1);
+            }
+        }
+    });
+    return evaluationCommand;
+}

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

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

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

@@ -0,0 +1,161 @@
+import { jest } from '@jest/globals';
+import { Command } from 'commander';
+const mockExecuteDirectEvaluation = jest.fn();
+const mockExecuteQueryEvaluation = jest.fn();
+jest.unstable_mockModule('../../lib/executeEvaluation.js', () => ({
+    executeDirectEvaluation: mockExecuteDirectEvaluation,
+    executeQueryEvaluation: mockExecuteQueryEvaluation,
+}));
+const { createEvaluationCommand } = await import('./index.js');
+describe('createEvaluationCommand', () => {
+    beforeEach(() => {
+        jest.clearAllMocks();
+    });
+    it('should create an evaluation command', () => {
+        const command = createEvaluationCommand({});
+        expect(command).toBeInstanceOf(Command);
+        expect(command.name()).toBe('evaluation');
+        expect(command.description()).toBe('Execute evaluations against evaluators');
+    });
+    describe('direct evaluation', () => {
+        it('should execute direct evaluation with required options', async () => {
+            mockExecuteDirectEvaluation.mockResolvedValue(undefined);
+            const command = createEvaluationCommand({});
+            await command.parseAsync([
+                'node',
+                'test',
+                'my-evaluator',
+                '--input',
+                'test-input',
+                '--output',
+                'test-output',
+            ]);
+            expect(mockExecuteDirectEvaluation).toHaveBeenCalledWith({
+                evaluatorName: 'my-evaluator',
+                input: 'test-input',
+                output: 'test-output',
+                timeout: undefined,
+                watchTimeout: undefined,
+            });
+        });
+        it('should execute direct evaluation with timeout options', async () => {
+            mockExecuteDirectEvaluation.mockResolvedValue(undefined);
+            const command = createEvaluationCommand({});
+            await command.parseAsync([
+                'node',
+                'test',
+                'my-evaluator',
+                '--input',
+                'test-input',
+                '--output',
+                'test-output',
+                '--timeout',
+                '10m',
+                '--watch-timeout',
+                '11m',
+            ]);
+            expect(mockExecuteDirectEvaluation).toHaveBeenCalledWith({
+                evaluatorName: 'my-evaluator',
+                input: 'test-input',
+                output: 'test-output',
+                timeout: '10m',
+                watchTimeout: '11m',
+            });
+        });
+    });
+    describe('query evaluation', () => {
+        it('should execute query evaluation with required arguments', async () => {
+            mockExecuteQueryEvaluation.mockResolvedValue(undefined);
+            const command = createEvaluationCommand({});
+            await command.parseAsync(['node', 'test', 'my-evaluator', 'test-query']);
+            expect(mockExecuteQueryEvaluation).toHaveBeenCalledWith({
+                evaluatorName: 'my-evaluator',
+                queryName: 'test-query',
+                responseTarget: undefined,
+                timeout: undefined,
+                watchTimeout: undefined,
+            });
+        });
+        it('should execute query evaluation from stdin', async () => {
+            mockExecuteQueryEvaluation.mockResolvedValue(undefined);
+            const command = createEvaluationCommand({});
+            const mockStdin = {
+                isTTY: false,
+                setEncoding: jest.fn(),
+                on: jest.fn((event, callback) => {
+                    if (event === 'data') {
+                        callback('piped-query-name');
+                    }
+                    else if (event === 'end') {
+                        callback();
+                    }
+                }),
+            };
+            const originalStdin = process.stdin;
+            Object.defineProperty(process, 'stdin', {
+                value: mockStdin,
+                writable: true,
+                configurable: true,
+            });
+            try {
+                await command.parseAsync(['node', 'test', 'my-evaluator']);
+                expect(mockExecuteQueryEvaluation).toHaveBeenCalledWith({
+                    evaluatorName: 'my-evaluator',
+                    queryName: 'piped-query-name',
+                    responseTarget: undefined,
+                    timeout: undefined,
+                    watchTimeout: undefined,
+                });
+            }
+            finally {
+                Object.defineProperty(process, 'stdin', {
+                    value: originalStdin,
+                    writable: true,
+                    configurable: true,
+                });
+            }
+        });
+        it('should execute query evaluation with response-target option', async () => {
+            mockExecuteQueryEvaluation.mockResolvedValue(undefined);
+            const command = createEvaluationCommand({});
+            await command.parseAsync([
+                'node',
+                'test',
+                'my-evaluator',
+                'test-query',
+                '--response-target',
+                'agent:my-agent',
+            ]);
+            expect(mockExecuteQueryEvaluation).toHaveBeenCalledWith({
+                evaluatorName: 'my-evaluator',
+                queryName: 'test-query',
+                responseTarget: 'agent:my-agent',
+                timeout: undefined,
+                watchTimeout: undefined,
+            });
+        });
+        it('should execute query evaluation with all options', async () => {
+            mockExecuteQueryEvaluation.mockResolvedValue(undefined);
+            const command = createEvaluationCommand({});
+            await command.parseAsync([
+                'node',
+                'test',
+                'my-evaluator',
+                'test-query',
+                '--response-target',
+                'agent:my-agent',
+                '--timeout',
+                '10m',
+                '--watch-timeout',
+                '11m',
+            ]);
+            expect(mockExecuteQueryEvaluation).toHaveBeenCalledWith({
+                evaluatorName: 'my-evaluator',
+                queryName: 'test-query',
+                responseTarget: 'agent:my-agent',
+                timeout: '10m',
+                watchTimeout: '11m',
+            });
+        });
+    });
+});

package/dist/commands/generate/generators/team.js

@@ -90,7 +90,10 @@ class TeamGenerator {
                     { name: 'Sequential - Agents execute in order', value: 'sequential' },
                     { name: 'Round Robin - Agents take turns', value: 'round-robin' },
                     { name: 'Graph - Custom workflow with dependencies', value: 'graph' },
-                    { name: 'Selector - AI chooses the next agent', value: 'selector' },
+                    {
+                        name: 'Selector - AI chooses the next agent (can add graph constraints)',
+                        value: 'selector',
+                    },
                 ],
                 default: 'sequential',
             },

package/dist/commands/install/index.js

@@ -5,6 +5,7 @@ import inquirer from 'inquirer';
 import { showNoClusterError } from '../../lib/startup.js';
 import output from '../../lib/output.js';
 import { getInstallableServices, arkDependencies, arkServices, } from '../../arkServices.js';
+import { isMarketplaceService, extractMarketplaceServiceName, getMarketplaceService, getAllMarketplaceServices, } from '../../marketplaceServices.js';
 import { printNextSteps } from '../../lib/nextSteps.js';
 import ora from 'ora';
 import { waitForServicesReady, } from '../../lib/waitForReady.js';
@@ -41,6 +42,32 @@ export async function installArk(config, serviceName, options = {}) {
     console.log(); // Add blank line after cluster info
     // If a specific service is requested, install 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(`installing marketplace service ${service.name}...`);
+            try {
+                await installService(service, options.verbose);
+                output.success(`${service.name} installed successfully`);
+            }
+            catch (error) {
+                output.error(`failed to install ${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/commands/marketplace/index.d.ts

@@ -0,0 +1,4 @@
+import { Command } from 'commander';
+import type { ArkConfig } from '../../lib/config.js';
+declare function createMarketplaceCommand(_config: ArkConfig): Command;
+export { createMarketplaceCommand };

package/dist/commands/marketplace/index.js

@@ -0,0 +1,50 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import { getAllMarketplaceServices } from '../../marketplaceServices.js';
+function createMarketplaceCommand(_config) {
+    const marketplace = new Command('marketplace');
+    marketplace
+        .description('Manage marketplace services')
+        .addHelpText('before', `
+${chalk.blue('🏪 ARK Marketplace')}
+Install community-contributed services from the ARK Marketplace.
+
+Repository: ${chalk.cyan('https://github.com/mckinsey/agents-at-scale-marketplace')}
+Registry: ${chalk.cyan('ghcr.io/mckinsey/agents-at-scale-marketplace/charts')}
+`)
+        .addHelpText('after', `
+${chalk.cyan('Examples:')}
+  ${chalk.yellow('ark marketplace list')}                        # List available services
+  ${chalk.yellow('ark install marketplace/services/phoenix')}    # Install Phoenix
+  ${chalk.yellow('ark uninstall marketplace/services/phoenix')}  # Uninstall Phoenix
+  
+${chalk.cyan('Available Services:')}
+  • phoenix  - AI/ML observability and evaluation platform
+  • langfuse - Open-source LLM observability and analytics
+`);
+    // List command
+    const list = new Command('list');
+    list
+        .alias('ls')
+        .description('List available marketplace services')
+        .action(() => {
+        const services = getAllMarketplaceServices();
+        console.log(chalk.blue('\n🏪 ARK Marketplace Services\n'));
+        console.log(chalk.gray('Install with: ark install marketplace/services/<service-name>\n'));
+        for (const [key, service] of Object.entries(services)) {
+            const icon = '📦';
+            const serviceName = `marketplace/services/${key.padEnd(12)}`;
+            const serviceDesc = service.description;
+            console.log(`${icon} ${chalk.green(serviceName)} ${chalk.gray(serviceDesc)}`);
+            const namespaceInfo = `namespace: ${service.namespace || 'default'}`;
+            console.log(`   ${chalk.dim(namespaceInfo)}`);
+            console.log();
+        }
+        console.log(chalk.cyan('Repository: https://github.com/mckinsey/agents-at-scale-marketplace'));
+        console.log(chalk.cyan('Registry: oci://ghcr.io/mckinsey/agents-at-scale-marketplace/charts'));
+        console.log();
+    });
+    marketplace.addCommand(list);
+    return marketplace;
+}
+export { createMarketplaceCommand };

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

@@ -0,0 +1,15 @@
+import { Command } from 'commander';
+import type { ArkConfig } from '../../lib/config.js';
+export declare function listSessions(options: {
+    output?: string;
+}): Promise<void>;
+export declare function deleteSession(sessionId: string, options: {
+    output?: string;
+}): Promise<void>;
+export declare function deleteQuery(sessionId: string, queryId: string, options: {
+    output?: string;
+}): Promise<void>;
+export declare function deleteAll(options: {
+    output?: string;
+}): Promise<void>;
+export declare function createMemoryCommand(_: ArkConfig): Command;

package/dist/commands/memory/index.js

@@ -0,0 +1,130 @@
+import { Command } from 'commander';
+import output from '../../lib/output.js';
+import { ArkApiProxy } from '../../lib/arkApiProxy.js';
+export async function listSessions(options) {
+    try {
+        const proxy = new ArkApiProxy();
+        const arkApiClient = await proxy.start();
+        const sessions = await arkApiClient.getSessions();
+        if (options.output === 'json') {
+            output.info(JSON.stringify(sessions, null, 2));
+            return;
+        }
+        if (sessions.length === 0) {
+            output.info('No sessions found');
+            return;
+        }
+        output.info('Sessions:');
+        sessions.forEach((session) => {
+            output.info(`  ${session.sessionId} (memory: ${session.memoryName})`);
+        });
+        proxy.stop();
+    }
+    catch (error) {
+        output.error('Failed to list sessions:', error);
+        process.exit(1);
+    }
+}
+export async function deleteSession(sessionId, options) {
+    try {
+        const proxy = new ArkApiProxy();
+        const arkApiClient = await proxy.start();
+        const response = await arkApiClient.deleteSession(sessionId);
+        if (options.output === 'json') {
+            output.info(JSON.stringify(response, null, 2));
+            return;
+        }
+        output.success(`Session ${sessionId} deleted successfully`);
+        proxy.stop();
+    }
+    catch (error) {
+        output.error(`Failed to delete session ${sessionId}:`, error);
+        process.exit(1);
+    }
+}
+export async function deleteQuery(sessionId, queryId, options) {
+    try {
+        const proxy = new ArkApiProxy();
+        const arkApiClient = await proxy.start();
+        const response = await arkApiClient.deleteQueryMessages(sessionId, queryId);
+        if (options.output === 'json') {
+            output.info(JSON.stringify(response, null, 2));
+            return;
+        }
+        output.success(`Query ${queryId} messages deleted successfully from session ${sessionId}`);
+        proxy.stop();
+    }
+    catch (error) {
+        output.error(`Failed to delete query ${queryId} messages:`, error);
+        process.exit(1);
+    }
+}
+export async function deleteAll(options) {
+    try {
+        const proxy = new ArkApiProxy();
+        const arkApiClient = await proxy.start();
+        const response = await arkApiClient.deleteAllSessions();
+        if (options.output === 'json') {
+            output.info(JSON.stringify(response, null, 2));
+            return;
+        }
+        output.success('All sessions deleted successfully');
+        proxy.stop();
+    }
+    catch (error) {
+        output.error('Failed to delete all sessions:', error);
+        process.exit(1);
+    }
+}
+export function createMemoryCommand(_) {
+    const memoryCommand = new Command('memory');
+    memoryCommand.description('Manage memory sessions and queries').alias('mem');
+    // List sessions command
+    memoryCommand
+        .command('list')
+        .alias('ls')
+        .description('List all sessions')
+        .option('-o, --output <format>', 'output format (json or text)', 'text')
+        .action(async (options) => {
+        await listSessions(options);
+    });
+    // Delete command with subcommands (alias: reset for backward compatibility)
+    const deleteCommand = memoryCommand
+        .command('delete')
+        .alias('reset')
+        .description('Delete memory data')
+        .option('--all', 'Delete all sessions and their messages');
+    // Delete specific session
+    deleteCommand
+        .command('session')
+        .description('Delete a specific session')
+        .argument('<sessionId>', 'Session ID to delete')
+        .option('-o, --output <format>', 'output format (json or text)', 'text')
+        .action(async (sessionId, options) => {
+        await deleteSession(sessionId, options);
+    });
+    // Delete specific query
+    deleteCommand
+        .command('query')
+        .description('Delete messages for a specific query')
+        .argument('<sessionId>', 'Session ID')
+        .argument('<queryId>', 'Query ID to delete messages for')
+        .option('-o, --output <format>', 'output format (json or text)', 'text')
+        .action(async (sessionId, queryId, options) => {
+        await deleteQuery(sessionId, queryId, options);
+    });
+    // Handle --all on delete root
+    deleteCommand.action(async (options) => {
+        if (options.all) {
+            await deleteAll(options);
+            return;
+        }
+        // If no subcommand and no --all, show help
+        deleteCommand.help();
+    });
+    // Default action - list sessions
+    memoryCommand.action(async (options) => {
+        await listSessions(options);
+    });
+    return memoryCommand;
+}

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

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