@agents-at-scale/ark 0.1.35-rc2 → 0.1.36-rc1

package/dist/arkServices.js

@@ -59,7 +59,7 @@ export const arkServices = {
     'ark-controller': {
         name: 'ark-controller',
         helmReleaseName: 'ark-controller',
-        description: 'Core ARK controller for managing AI resources',
+        description: 'Core Ark controller for managing AI resources',
         enabled: true,
         namespace: 'ark-system',
         chartPath: `${REGISTRY_BASE}/ark-controller`,
@@ -70,7 +70,7 @@ export const arkServices = {
     'ark-api': {
         name: 'ark-api',
         helmReleaseName: 'ark-api',
-        description: 'ARK API service for interacting with ARK resources',
+        description: 'API layer for interacting with Ark resources',
         enabled: true,
         // namespace: undefined - uses current context namespace
         chartPath: `${REGISTRY_BASE}/ark-api`,
@@ -84,7 +84,7 @@ export const arkServices = {
     'ark-dashboard': {
         name: 'ark-dashboard',
         helmReleaseName: 'ark-dashboard',
-        description: 'Web-based dashboard for ARK',
+        description: 'Ark Dashboard',
         enabled: true,
         // namespace: undefined - uses current context namespace
         chartPath: `${REGISTRY_BASE}/ark-dashboard`,
@@ -98,7 +98,7 @@ export const arkServices = {
     'ark-api-a2a': {
         name: 'ark-api-a2a',
         helmReleaseName: 'ark-api-a2a',
-        description: 'ARK API agent-to-agent communication service',
+        description: 'Ark API agent-to-agent communication service',
         enabled: false, // Disabled - not currently used
         // namespace: undefined - uses current context namespace
         // Note: This service might be installed as part of ark-api or separately
@@ -106,7 +106,7 @@ export const arkServices = {
     'ark-mcp': {
         name: 'ark-mcp',
         helmReleaseName: 'ark-mcp',
-        description: 'MCP (Model Context Protocol) services for ARK',
+        description: 'Ark Model Context Protocol server',
         enabled: true,
         // namespace: undefined - uses current context namespace
         chartPath: `${REGISTRY_BASE}/ark-mcp`,
@@ -117,8 +117,8 @@ export const arkServices = {
     'localhost-gateway': {
         name: 'localhost-gateway',
         helmReleaseName: 'localhost-gateway',
-        description: 'Gateway for local cluster access',
-        enabled: true,
+        description: 'Gateway for local development clusters',
+        enabled: false, // Disabled - not needed for most users
         namespace: 'ark-system',
         chartPath: `${REGISTRY_BASE}/localhost-gateway`,
         installArgs: [],

package/dist/commands/agents/index.js

@@ -1,6 +1,7 @@
 import { Command } from 'commander';
 import { execa } from 'execa';
 import output from '../../lib/output.js';
+import { executeQuery } from '../../lib/executeQuery.js';
 async function listAgents(options) {
     try {
         // Use kubectl to get agents
@@ -47,5 +48,18 @@ export function createAgentsCommand(_) {
         .action(async (options) => {
         await listAgents(options);
     });
+    // Add query subcommand
+    agentsCommand
+        .command('query')
+        .description('Query an agent')
+        .argument('<name>', 'Agent name')
+        .argument('<message>', 'Message to send')
+        .action(async (name, message) => {
+        await executeQuery({
+            targetType: 'agent',
+            targetName: name,
+            message,
+        });
+    });
     return agentsCommand;
 }

package/dist/commands/completion/index.js

@@ -28,7 +28,7 @@ _ark_completion() {
   
   case \${COMP_CWORD} in
     1)
-      opts="agents chat cluster completion config dashboard dev docs generate install models query routes status targets teams tools uninstall help"
+      opts="agents chat cluster completion config dashboard docs generate install models query routes status targets teams tools uninstall help"
       COMPREPLY=( $(compgen -W "\${opts}" -- \${cur}) )
       return 0
       ;;
@@ -74,11 +74,6 @@ _ark_completion() {
           COMPREPLY=( $(compgen -W "\${opts}" -- \${cur}) )
           return 0
           ;;
-        dev)
-          opts="tool"
-          COMPREPLY=( $(compgen -W "\${opts}" -- \${cur}) )
-          return 0
-          ;;
         generate)
           opts="agent marketplace mcp-server project query team"
           COMPREPLY=( $(compgen -W "\${opts}" -- \${cur}) )
@@ -108,35 +103,6 @@ _ark_completion() {
           ;;
       esac
       ;;
-    3)
-      case \${COMP_WORDS[1]} in
-        dev)
-          case \${prev} in
-            tool)
-              opts="check init generate"
-              COMPREPLY=( $(compgen -W "\${opts}" -- \${cur}) )
-              return 0
-              ;;
-          esac
-          ;;
-      esac
-      ;;
-    4)
-      # Handle path completion for dev tool commands
-      case \${COMP_WORDS[1]} in
-        dev)
-          if [[ \${COMP_WORDS[2]} == "tool" ]]; then
-            case \${COMP_WORDS[3]} in
-              check|init|generate)
-                # Complete with directories
-                COMPREPLY=( $(compgen -d -- \${cur}) )
-                return 0
-                ;;
-            esac
-          fi
-          ;;
-      esac
-      ;;
   esac
 }
 
@@ -169,7 +135,6 @@ _ark() {
         'completion[Generate shell completion scripts]' \\
         'config[Configuration management]' \\
         'dashboard[Open ARK dashboard]' \\
-        'dev[Development tools for ARK]' \\
         'docs[Open ARK documentation]' \\
         'generate[Generate ARK resources]' \\
         'install[Install ARK services]' \\
@@ -225,10 +190,6 @@ _ark() {
             'list[List all available tools]' \\
             'ls[List all available tools]'
           ;;
-        dev)
-          _values 'dev commands' \\
-            'tool[MCP tool development utilities]'
-          ;;
         generate)
           _values 'generate types' \\
             'agent[Generate a new agent]' \\
@@ -258,27 +219,6 @@ _ark() {
           ;;
       esac
       ;;
-    args)
-      case \$words[2] in
-        dev)
-          if [[ \$words[3] == "tool" ]]; then
-            case \$words[4] in
-              check|init|generate)
-                # Complete with directories
-                _files -/
-                ;;
-              *)
-                _values 'tool commands' \\
-                  'check[Check the status of an MCP tool project]' \\
-                  'init[Initialize an MCP tool project]' \\
-                  'generate[Generate project files from templates]' \\
-                  'clean[Remove template-generated files]'
-                ;;
-            esac
-          fi
-          ;;
-      esac
-      ;;
   esac
 }
 

package/dist/commands/dev/tool/shared.js

@@ -242,7 +242,9 @@ function processTemplateFile(templatePath, targetFileName, arkConfig, options, r
             }
         }
         catch (helmError) {
-            const errorMsg = helmError.stderr || helmError.message || 'Unknown error';
+            const errorMsg = helmError.stderr ||
+                helmError.message ||
+                'Unknown error';
             throw new Error(`Failed to template ${targetFileName}: ${errorMsg}`);
         }
         return content;

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

@@ -144,11 +144,11 @@ class AgentGenerator {
             console.log(chalk.gray(`  1. Review and customise the agent configuration`));
             if (config.createQuery) {
                 console.log(chalk.gray(`  2. Review and customise the query configuration`));
-                console.log(chalk.gray(`  3. Deploy with: helm upgrade --install ${config.projectName} .`));
+                console.log(chalk.gray(`  3. Deploy with: helm upgrade --install ${config.projectName} . --namespace ${config.projectName}`));
                 console.log(chalk.gray(`  4. Test with: kubectl get agents,queries`));
             }
             else {
-                console.log(chalk.gray(`  2. Deploy with: helm upgrade --install ${config.projectName} .`));
+                console.log(chalk.gray(`  2. Deploy with: helm upgrade --install ${config.projectName} . --namespace ${config.projectName}`));
                 console.log(chalk.gray(`  3. Test with: kubectl get agents`));
             }
         }, 'Generating agent');

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

@@ -391,11 +391,11 @@ class TeamGenerator {
             console.log(chalk.gray(`  1. Review and customise the team configuration`));
             if (config.createQuery) {
                 console.log(chalk.gray(`  2. Review and customise the query configuration`));
-                console.log(chalk.gray(`  3. Deploy with: helm upgrade --install ${config.projectName} .`));
+                console.log(chalk.gray(`  3. Deploy with: helm upgrade --install ${config.projectName} . --namespace ${config.projectName}`));
                 console.log(chalk.gray(`  4. Test with: kubectl get teams,queries`));
             }
             else {
-                console.log(chalk.gray(`  2. Deploy with: helm upgrade --install ${config.projectName} .`));
+                console.log(chalk.gray(`  2. Deploy with: helm upgrade --install ${config.projectName} . --namespace ${config.projectName}`));
                 console.log(chalk.gray(`  3. Test with: kubectl get teams`));
             }
         }

package/dist/commands/install/index.js

@@ -4,7 +4,7 @@ import { execute } from '../../lib/commands.js';
 import inquirer from 'inquirer';
 import { showNoClusterError } from '../../lib/startup.js';
 import output from '../../lib/output.js';
-import { getInstallableServices, arkDependencies } from '../../arkServices.js';
+import { getInstallableServices, arkDependencies, } from '../../arkServices.js';
 import { isArkReady } from '../../lib/arkStatus.js';
 import { printNextSteps } from '../../lib/nextSteps.js';
 import ora from 'ora';
@@ -37,11 +37,6 @@ export async function installArk(config, serviceName, options = {}) {
     const clusterInfo = config.clusterInfo;
     // Show cluster info
     output.success(`connected to cluster: ${chalk.bold(clusterInfo.context)}`);
-    output.info(`type: ${clusterInfo.type}`);
-    output.info(`namespace: ${clusterInfo.namespace}`);
-    if (clusterInfo.ip) {
-        output.info(`ip: ${clusterInfo.ip}`);
-    }
     console.log(); // Add blank line after cluster info
     // If a specific service is requested, install only that service
     if (serviceName) {

package/dist/commands/models/index.js

@@ -2,6 +2,7 @@ import { Command } from 'commander';
 import { execa } from 'execa';
 import output from '../../lib/output.js';
 import { createModel } from './create.js';
+import { executeQuery } from '../../lib/executeQuery.js';
 async function listModels(options) {
     try {
         // Use kubectl to get models
@@ -56,5 +57,19 @@ export function createModelsCommand(_) {
         await createModel(name);
     });
     modelsCommand.addCommand(createCommand);
+    // Add query command
+    const queryCommand = new Command('query');
+    queryCommand
+        .description('Query a model')
+        .argument('<name>', 'Model name (e.g., default)')
+        .argument('<message>', 'Message to send')
+        .action(async (name, message) => {
+        await executeQuery({
+            targetType: 'model',
+            targetName: name,
+            message,
+        });
+    });
+    modelsCommand.addCommand(queryCommand);
     return modelsCommand;
 }

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

@@ -15,6 +15,11 @@ const mockCreateModel = jest.fn();
 jest.unstable_mockModule('./create.js', () => ({
     createModel: mockCreateModel,
 }));
+const mockExecuteQuery = jest.fn();
+jest.unstable_mockModule('../../lib/executeQuery.js', () => ({
+    executeQuery: mockExecuteQuery,
+    parseTarget: jest.fn(),
+}));
 const mockExit = jest.spyOn(process, 'exit').mockImplementation((() => {
     throw new Error('process.exit called');
 }));
@@ -73,4 +78,19 @@ describe('models command', () => {
         await command.parseAsync(['node', 'test', 'create', 'my-model']);
         expect(mockCreateModel).toHaveBeenCalledWith('my-model');
     });
+    it('query subcommand works', async () => {
+        const command = createModelsCommand({});
+        await command.parseAsync([
+            'node',
+            'test',
+            'query',
+            'default',
+            'Hello world',
+        ]);
+        expect(mockExecuteQuery).toHaveBeenCalledWith({
+            targetType: 'model',
+            targetName: 'default',
+            message: 'Hello world',
+        });
+    });
 });

package/dist/commands/query/index.js

@@ -1,118 +1,6 @@
 import { Command } from 'commander';
-import { execa } from 'execa';
-import ora from 'ora';
 import output from '../../lib/output.js';
-async function runQuery(target, message) {
-    const spinner = ora('Creating query...').start();
-    // Generate a unique query name
-    const timestamp = Date.now();
-    const queryName = `cli-query-${timestamp}`;
-    // Parse the target format (e.g., model/default -> type: model, name: default)
-    const [targetType, targetName] = target.split('/');
-    // Create the Query resource
-    const queryManifest = {
-        apiVersion: 'ark.mckinsey.com/v1alpha1',
-        kind: 'Query',
-        metadata: {
-            name: queryName,
-        },
-        spec: {
-            input: message,
-            targets: [
-                {
-                    type: targetType,
-                    name: targetName,
-                },
-            ],
-        },
-    };
-    try {
-        // Apply the query
-        spinner.text = 'Submitting query...';
-        await execa('kubectl', ['apply', '-f', '-'], {
-            input: JSON.stringify(queryManifest),
-            stdio: ['pipe', 'pipe', 'pipe'],
-        });
-        // Watch for query completion
-        spinner.text = 'Query status: initializing';
-        let queryComplete = false;
-        let attempts = 0;
-        const maxAttempts = 300; // 5 minutes with 1 second intervals
-        while (!queryComplete && attempts < maxAttempts) {
-            attempts++;
-            try {
-                const { stdout } = await execa('kubectl', [
-                    'get',
-                    'query',
-                    queryName,
-                    '-o',
-                    'json',
-                ], { stdio: 'pipe' });
-                const query = JSON.parse(stdout);
-                const phase = query.status?.phase;
-                // Update spinner with current phase
-                if (phase) {
-                    spinner.text = `Query status: ${phase}`;
-                }
-                // Check if query is complete based on phase
-                if (phase === 'done') {
-                    queryComplete = true;
-                    spinner.succeed('Query completed');
-                    // 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('\n' + (response.content || response));
-                    }
-                    else {
-                        output.warning('No response received');
-                    }
-                }
-                else if (phase === 'error') {
-                    queryComplete = true;
-                    spinner.fail('Query failed');
-                    // Try to get error message from conditions or status
-                    const errorCondition = query.status?.conditions?.find((c) => {
-                        const condition = c;
-                        return condition.type === 'Complete' && condition.status === 'False';
-                    });
-                    if (errorCondition?.message) {
-                        output.error(errorCondition.message);
-                    }
-                    else if (query.status?.error) {
-                        output.error(query.status.error);
-                    }
-                    else {
-                        output.error('Query failed with unknown error');
-                    }
-                }
-                else if (phase === 'canceled') {
-                    queryComplete = true;
-                    spinner.warn('Query canceled');
-                    // Try to get cancellation reason if available
-                    if (query.status?.message) {
-                        output.warning(query.status.message);
-                    }
-                }
-            }
-            catch {
-                // Query might not exist yet, continue waiting
-                spinner.text = 'Running query: waiting for query to be created';
-            }
-            if (!queryComplete) {
-                await new Promise(resolve => setTimeout(resolve, 1000)); // Wait 1 second
-            }
-        }
-        if (!queryComplete) {
-            spinner.fail('Query timed out');
-            output.error('Query did not complete within 5 minutes');
-        }
-    }
-    catch (error) {
-        spinner.fail('Query failed');
-        output.error(error instanceof Error ? error.message : 'Unknown error');
-        process.exit(1);
-    }
-}
+import { executeQuery, parseTarget } from '../../lib/executeQuery.js';
 export function createQueryCommand(_) {
     const queryCommand = new Command('query');
     queryCommand
@@ -120,12 +8,17 @@ export function createQueryCommand(_) {
         .argument('<target>', 'Query target (e.g., model/default, agent/my-agent)')
         .argument('<message>', 'Message to send')
         .action(async (target, message) => {
-        // Validate target format
-        if (!target.includes('/')) {
+        // Parse and validate target format
+        const parsed = parseTarget(target);
+        if (!parsed) {
             output.error('Invalid target format. Use: model/name or agent/name etc');
             process.exit(1);
         }
-        await runQuery(target, message);
+        await executeQuery({
+            targetType: parsed.type,
+            targetName: parsed.name,
+            message,
+        });
     });
     return queryCommand;
 }

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

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

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

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

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

@@ -1,4 +1,3 @@
 import { Command } from 'commander';
-import type { ArkConfig } from '../../lib/config.js';
-export declare function checkStatus(config: ArkConfig): Promise<void>;
-export declare function createStatusCommand(config: ArkConfig): Command;
+export declare function checkStatus(): Promise<void>;
+export declare function createStatusCommand(): Command;

package/dist/commands/status/index.js

@@ -3,10 +3,11 @@ import chalk from 'chalk';
 import ora from 'ora';
 import { StatusChecker } from '../../components/statusChecker.js';
 import { StatusFormatter, } from '../../ui/statusFormatter.js';
+import { fetchVersionInfo } from '../../lib/versions.js';
 /**
  * Enrich service with formatted details including version/revision
  */
-function enrichServiceDetails(service, _) {
+function enrichServiceDetails(service) {
     const statusMap = {
         healthy: { icon: '✓', text: 'healthy', color: 'green' },
         unhealthy: { icon: '✗', text: 'unhealthy', color: 'red' },
@@ -43,7 +44,7 @@ function enrichServiceDetails(service, _) {
         details: details.join(', '),
     };
 }
-function buildStatusSections(data, config) {
+function buildStatusSections(data, versionInfo) {
     const sections = [];
     // Dependencies section
     sections.push({
@@ -97,7 +98,7 @@ function buildStatusSections(data, config) {
         const serviceLines = data.services
             .filter((s) => s.name !== 'ark-controller')
             .map((service) => {
-            const { statusInfo, displayName, details } = enrichServiceDetails(service, config);
+            const { statusInfo, displayName, details } = enrichServiceDetails(service);
             return {
                 icon: statusInfo.icon,
                 iconColor: statusInfo.color,
@@ -144,7 +145,7 @@ function buildStatusSections(data, config) {
             });
         }
         else {
-            const { statusInfo, displayName, details } = enrichServiceDetails(controller, config);
+            const { statusInfo, displayName, details } = enrichServiceDetails(controller);
             // Map service status to ark status display
             const statusText = controller.status === 'healthy'
                 ? 'ready'
@@ -160,28 +161,42 @@ function buildStatusSections(data, config) {
                 details: details,
             });
             // Add version update status as separate line
-            if (controller.status === 'healthy' && controller.version && config) {
-                if (config.latestVersion === undefined) {
+            if (controller.status === 'healthy' && versionInfo) {
+                const currentVersion = versionInfo.current || controller.version;
+                if (!currentVersion) {
+                    // Version is unknown
                     arkStatusLines.push({
                         icon: '?',
                         iconColor: 'yellow',
-                        status: 'version check',
+                        status: 'version unknown',
+                        statusColor: 'yellow',
+                        name: '',
+                        details: versionInfo.latest
+                            ? `latest: ${versionInfo.latest}`
+                            : 'unable to determine version',
+                    });
+                }
+                else if (versionInfo.latest === undefined) {
+                    // Have current version but couldn't check for updates
+                    arkStatusLines.push({
+                        icon: '?',
+                        iconColor: 'yellow',
+                        status: `version ${currentVersion}`,
                         statusColor: 'yellow',
                         name: '',
                         details: 'unable to check for updates',
                     });
                 }
                 else {
-                    // Use currentVersion from config if available, otherwise use controller.version
-                    const currentVersion = config.currentVersion || controller.version;
-                    if (currentVersion === config.latestVersion) {
+                    // Have both current and latest versions
+                    if (currentVersion === versionInfo.latest) {
                         arkStatusLines.push({
                             icon: '✓',
                             iconColor: 'green',
                             status: 'up to date',
                             statusColor: 'green',
                             name: '',
-                            details: config.latestVersion,
+                            details: versionInfo.latest,
                         });
                     }
                     else {
@@ -191,7 +206,7 @@ function buildStatusSections(data, config) {
                             status: 'update available',
                             statusColor: 'yellow',
                             name: '',
-                            details: config.latestVersion,
+                            details: `${currentVersion} → ${versionInfo.latest}`,
                         });
                     }
                 }
@@ -234,16 +249,20 @@ function buildStatusSections(data, config) {
     sections.push({ title: 'ark status:', lines: arkStatusLines });
     return sections;
 }
-export async function checkStatus(config) {
+export async function checkStatus() {
     const spinner = ora('Checking system status').start();
     try {
         spinner.text = 'Checking system dependencies';
         const statusChecker = new StatusChecker();
         spinner.text = 'Testing cluster access';
         spinner.text = 'Checking ARK services';
-        const statusData = await statusChecker.checkAll();
+        // Run status check and version fetch in parallel
+        const [statusData, versionInfo] = await Promise.all([
+            statusChecker.checkAll(),
+            fetchVersionInfo(),
+        ]);
         spinner.stop();
-        const sections = buildStatusSections(statusData, config);
+        const sections = buildStatusSections(statusData, versionInfo);
         StatusFormatter.printSections(sections);
         process.exit(0);
     }
@@ -253,10 +272,10 @@ export async function checkStatus(config) {
         process.exit(1);
     }
 }
-export function createStatusCommand(config) {
+export function createStatusCommand() {
     const statusCommand = new Command('status');
     statusCommand
         .description('Check ARK system status')
-        .action(() => checkStatus(config));
+        .action(() => checkStatus());
     return statusCommand;
 }