@agents-at-scale/ark 0.1.42 → 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 queries 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
@@ -102,7 +119,7 @@ _ark_completion() {
           return 0
           ;;
         queries)
-          opts="get"
+          opts="get delete resubmit"
           COMPREPLY=( $(compgen -W "\${opts}" -- \${cur}) )
           return 0
           ;;
@@ -142,6 +159,7 @@ _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]' \\
@@ -204,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
@@ -224,7 +257,9 @@ _ark() {
           ;;
         queries)
           _values 'queries commands' \\
-            'get[Get a specific query]'
+            'get[Get a specific query]' \\
+            'delete[Delete a query]' \\
+            'resubmit[Resubmit a query by clearing its status]'
           ;;
       esac
       ;;

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

@@ -67,12 +67,7 @@ describe('createEvaluationCommand', () => {
         it('should execute query evaluation with required arguments', async () => {
             mockExecuteQueryEvaluation.mockResolvedValue(undefined);
             const command = createEvaluationCommand({});
-            await command.parseAsync([
-                'node',
-                'test',
-                'my-evaluator',
-                'test-query',
-            ]);
+            await command.parseAsync(['node', 'test', 'my-evaluator', 'test-query']);
             expect(mockExecuteQueryEvaluation).toHaveBeenCalledWith({
                 evaluatorName: 'my-evaluator',
                 queryName: 'test-query',

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/models/create.js

@@ -1,7 +1,7 @@
 import { execa } from 'execa';
 import inquirer from 'inquirer';
 import output from '../../lib/output.js';
-import { ProviderConfigCollectorFactory } from './providers/index.js';
+import { ProviderConfigCollectorFactory, } from './providers/index.js';
 import { KubernetesSecretManager } from './kubernetes/secret-manager.js';
 import { KubernetesModelManifestBuilder } from './kubernetes/manifest-builder.js';
 export async function createModel(modelName, options = {}) {

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

@@ -32,9 +32,13 @@ describe('createModel', () => {
             .mockResolvedValueOnce({ model: 'anthropic.claude-3-sonnet-20240229-v1:0' })
             .mockResolvedValueOnce({ region: 'us-east-1' })
             .mockResolvedValueOnce({ accessKeyId: 'AKIAIOSFODNN7EXAMPLE' })
-            .mockResolvedValueOnce({ secretAccessKey: 'wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY' })
+            .mockResolvedValueOnce({
+            secretAccessKey: 'wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY',
+        })
             .mockResolvedValueOnce({ sessionToken: 'optional-session-token' })
-            .mockResolvedValueOnce({ modelArn: 'arn:aws:bedrock:us-east-1:123456789012:model/anthropic.claude-3-sonnet-20240229-v1:0' });
+            .mockResolvedValueOnce({
+            modelArn: 'arn:aws:bedrock:us-east-1:123456789012:model/anthropic.claude-3-sonnet-20240229-v1:0',
+        });
         mockExeca.mockResolvedValue({}); // kubectl ops succeed
         await createModel('test-model');
         // Verify that model type prompt was called

package/dist/commands/models/providers/azure.spec.js

@@ -93,7 +93,9 @@ describe('AzureConfigCollector', () => {
                 expect(validate('https://test.openai.azure.com')).toBe(true);
                 return { baseUrl: 'https://test.openai.azure.com' };
             });
-            mockInquirer.prompt.mockResolvedValueOnce({ apiVersion: '2024-12-01-preview' });
+            mockInquirer.prompt.mockResolvedValueOnce({
+                apiVersion: '2024-12-01-preview',
+            });
             mockInquirer.prompt.mockResolvedValueOnce({ apiKey: 'azure-key' });
             await collector.collectConfig(options);
         });

package/dist/commands/queries/delete.d.ts

@@ -0,0 +1,7 @@
+interface DeleteQueryOptions {
+    all?: boolean;
+}
+export declare const MISSING_NAME_OR_ALL_ERROR = "either provide a query name or use --all flag";
+export declare const BOTH_NAME_AND_ALL_ERROR = "cannot use query name and --all flag together";
+export declare function deleteQuery(name: string | undefined, options: DeleteQueryOptions): Promise<void>;
+export {};

package/dist/commands/queries/delete.js

@@ -0,0 +1,24 @@
+import output from '../../lib/output.js';
+import { ExitCodes } from '../../lib/errors.js';
+import { deleteResource } from '../../lib/kubectl.js';
+import { InvalidArgumentError } from 'commander';
+export const MISSING_NAME_OR_ALL_ERROR = 'either provide a query name or use --all flag';
+export const BOTH_NAME_AND_ALL_ERROR = 'cannot use query name and --all flag together';
+function assertDeleteOptionsValid(name, options) {
+    if (!name && !options.all) {
+        throw new InvalidArgumentError(MISSING_NAME_OR_ALL_ERROR);
+    }
+    if (name && options.all) {
+        throw new InvalidArgumentError(BOTH_NAME_AND_ALL_ERROR);
+    }
+}
+export async function deleteQuery(name, options) {
+    try {
+        assertDeleteOptionsValid(name, options);
+        await deleteResource('queries', name, options);
+    }
+    catch (error) {
+        output.error('deleting query:', error instanceof Error ? error.message : error);
+        process.exit(ExitCodes.CliError);
+    }
+}

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

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

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

@@ -0,0 +1,74 @@
+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.js

@@ -1,17 +1,20 @@
 import { Command } from 'commander';
 import { marked } from 'marked';
+// @ts-ignore - no types available
 import TerminalRenderer from 'marked-terminal';
 import output from '../../lib/output.js';
 import { ExitCodes } from '../../lib/errors.js';
-import { getResource } from '../../lib/kubectl.js';
+import { getResource, replaceResource } from '../../lib/kubectl.js';
+import { listQueries } from './list.js';
+import { deleteQuery } from './delete.js';
 function renderMarkdown(content) {
     if (process.stdout.isTTY) {
         marked.setOptions({
-            // @ts-expect-error - TerminalRenderer types are incomplete
+            // @ts-ignore - TerminalRenderer types are incomplete
             renderer: new TerminalRenderer({
                 showSectionPrefix: false,
                 reflowText: true,
-                // @ts-expect-error - preserveNewlines exists but not in types
+                // @ts-ignore - preserveNewlines exists but not in types
                 preserveNewlines: true,
             }),
         });
@@ -55,7 +58,13 @@ async function getQuery(name, options) {
 }
 export function createQueriesCommand(_) {
     const queriesCommand = new Command('queries');
-    queriesCommand.description('Manage query resources');
+    queriesCommand
+        .description('List all queries')
+        .option('-o, --output <format>', 'output format (json or text)', 'text')
+        .option('--sort-by <field>', 'sort by kubernetes field (e.g., .metadata.name)')
+        .action(async (options) => {
+        await listQueries(options);
+    });
     const getCommand = new Command('get');
     getCommand
         .description('Get a specific query (@latest for most recent)')
@@ -66,5 +75,34 @@ export function createQueriesCommand(_) {
         await getQuery(name, options);
     });
     queriesCommand.addCommand(getCommand);
+    const deleteCommand = new Command('delete');
+    deleteCommand
+        .description('Delete a query')
+        .argument('[name]', 'Query name')
+        .option('--all', 'delete all queries', false)
+        .action(async (name, options) => {
+        await deleteQuery(name, options);
+    });
+    queriesCommand.addCommand(deleteCommand);
+    const resubmitCommand = new Command('resubmit');
+    resubmitCommand
+        .description('Resubmit a query by clearing its status (@latest for most recent)')
+        .argument('<name>', 'Query name or @latest')
+        .action(async (name) => {
+        try {
+            const query = await getResource('queries', name);
+            const queryWithoutStatus = {
+                ...query,
+                status: undefined,
+            };
+            await replaceResource(queryWithoutStatus);
+            output.success(`Query '${query.metadata.name}' resubmitted`);
+        }
+        catch (error) {
+            output.error('resubmitting query:', error instanceof Error ? error.message : error);
+            process.exit(ExitCodes.CliError);
+        }
+    });
+    queriesCommand.addCommand(resubmitCommand);
     return queriesCommand;
 }

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

@@ -0,0 +1,6 @@
+interface ListQueriesOptions {
+    output?: string;
+    sortBy?: string;
+}
+export declare function listQueries(options: ListQueriesOptions): Promise<void>;
+export {};

package/dist/commands/queries/list.js

@@ -0,0 +1,66 @@
+import chalk from 'chalk';
+import output from '../../lib/output.js';
+import { ExitCodes } from '../../lib/errors.js';
+import { listResources } from '../../lib/kubectl.js';
+import { assertSupportedOutputFormat } from './validation.js';
+// Output format constants
+const OUTPUT_FORMAT_JSON = 'json';
+// Query phase constants
+const PHASE_DONE = 'done';
+const PHASE_RUNNING = 'running';
+const PHASE_ERROR = 'error';
+const PHASE_UNKNOWN = 'unknown';
+// Column padding
+const COLUMN_PADDING = 2;
+const MIN_NAME_LENGTH = 4;
+function getStatusColor(status) {
+    switch (status) {
+        case PHASE_DONE:
+            return chalk.green;
+        case PHASE_RUNNING:
+            return chalk.blue;
+        case PHASE_ERROR:
+            return chalk.red;
+        default:
+            return chalk.yellow;
+    }
+}
+function printTableHeader(maxNameLength) {
+    const paddedHeaderLength = maxNameLength + COLUMN_PADDING;
+    const header = `${'NAME'.padEnd(paddedHeaderLength)}${'STATUS'}`;
+    console.log(header);
+}
+function printTableRow(query, maxNameLength) {
+    const status = query.status?.phase || PHASE_UNKNOWN;
+    const statusColor = getStatusColor(status);
+    const paddedNameLength = maxNameLength + COLUMN_PADDING;
+    console.log(`${query.metadata.name.padEnd(paddedNameLength)}${statusColor(status)}`);
+}
+function printResult(queries, options) {
+    if (options.output === OUTPUT_FORMAT_JSON) {
+        console.log(JSON.stringify(queries, null, 2));
+        return;
+    }
+    if (queries.length === 0) {
+        output.warning('no queries available');
+        return;
+    }
+    const maxNameLength = Math.max(MIN_NAME_LENGTH, ...queries.map((q) => q.metadata.name.length));
+    printTableHeader(maxNameLength);
+    queries.forEach((query) => {
+        printTableRow(query, maxNameLength);
+    });
+}
+export async function listQueries(options) {
+    try {
+        assertSupportedOutputFormat(options.output);
+        const queries = await listResources('queries', {
+            sortBy: options.sortBy,
+        });
+        printResult(queries, options);
+    }
+    catch (error) {
+        output.error('fetching queries:', error instanceof Error ? error.message : error);
+        process.exit(ExitCodes.CliError);
+    }
+}

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

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