@agents-at-scale/ark 0.1.35-rc.1 → 0.1.35-rc2

package/dist/arkServices.d.ts

@@ -5,15 +5,15 @@ export interface ArkService {
     name: string;
     helmReleaseName: string;
     description: string;
-    namespace: string;
-    healthPath?: string;
-    gatewayUrl?: string;
+    enabled: boolean;
+    namespace?: string;
     chartPath?: string;
     installArgs?: string[];
     k8sServiceName?: string;
     k8sServicePort?: number;
     k8sPortForwardLocalPort?: number;
     k8sDeploymentName?: string;
+    k8sDevDeploymentName?: string;
 }
 export interface ServiceCollection {
     [key: string]: ArkService;
@@ -37,14 +37,6 @@ export declare const arkDependencies: DependencyCollection;
  */
 export declare const arkServices: ServiceCollection;
 /**
- * Get services that can be installed via Helm charts
+ * Get services that can be installed via Helm charts (only enabled services)
  */
 export declare function getInstallableServices(): ServiceCollection;
-/**
- * Get services that can be checked for status
- */
-export declare function getStatusCheckableServices(): Record<string, string>;
-/**
- * Get health check path for a specific service
- */
-export declare function getHealthPath(serviceName: string): string;

package/dist/arkServices.js

@@ -1,7 +1,6 @@
 /**
  * Centralized ARK service definitions used by both install and status commands
  */
-const LOCALHOST_GATEWAY_PORT = 8080;
 const REGISTRY_BASE = 'oci://ghcr.io/mckinsey/agents-at-scale-ark/charts';
 /**
  * Dependencies that should be installed before ARK services
@@ -61,93 +60,79 @@ export const arkServices = {
         name: 'ark-controller',
         helmReleaseName: 'ark-controller',
         description: 'Core ARK controller for managing AI resources',
+        enabled: true,
         namespace: 'ark-system',
         chartPath: `${REGISTRY_BASE}/ark-controller`,
         installArgs: ['--create-namespace', '--set', 'rbac.enable=true'],
         k8sDeploymentName: 'ark-controller',
+        k8sDevDeploymentName: 'ark-controller-devspace',
     },
     'ark-api': {
         name: 'ark-api',
         helmReleaseName: 'ark-api',
         description: 'ARK API service for interacting with ARK resources',
-        namespace: 'default',
-        healthPath: '/health',
-        gatewayUrl: `http://ark-api.127.0.0.1.nip.io:${LOCALHOST_GATEWAY_PORT}`,
+        enabled: true,
+        // namespace: undefined - uses current context namespace
         chartPath: `${REGISTRY_BASE}/ark-api`,
         installArgs: [],
         k8sServiceName: 'ark-api',
         k8sServicePort: 80,
-        k8sPortForwardLocalPort: 34780,
         k8sDeploymentName: 'ark-api',
+        k8sDevDeploymentName: 'ark-api-devspace',
+        k8sPortForwardLocalPort: 34780,
     },
     'ark-dashboard': {
         name: 'ark-dashboard',
         helmReleaseName: 'ark-dashboard',
         description: 'Web-based dashboard for ARK',
-        namespace: 'default',
-        healthPath: '',
-        gatewayUrl: `http://dashboard.127.0.0.1.nip.io:${LOCALHOST_GATEWAY_PORT}`,
+        enabled: true,
+        // namespace: undefined - uses current context namespace
         chartPath: `${REGISTRY_BASE}/ark-dashboard`,
         installArgs: [],
         k8sServiceName: 'ark-dashboard',
         k8sServicePort: 3000,
-        k8sPortForwardLocalPort: 3274,
         k8sDeploymentName: 'ark-dashboard',
+        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',
-        namespace: 'default',
-        healthPath: '/health',
-        gatewayUrl: `http://ark-api-a2a.127.0.0.1.nip.io:${LOCALHOST_GATEWAY_PORT}`,
+        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
     },
     'ark-mcp': {
         name: 'ark-mcp',
         helmReleaseName: 'ark-mcp',
         description: 'MCP (Model Context Protocol) services for ARK',
-        namespace: 'default',
+        enabled: true,
+        // namespace: undefined - uses current context namespace
         chartPath: `${REGISTRY_BASE}/ark-mcp`,
         installArgs: [],
+        k8sDeploymentName: 'ark-mcp',
+        k8sDevDeploymentName: 'ark-mcp-devspace',
     },
     'localhost-gateway': {
         name: 'localhost-gateway',
         helmReleaseName: 'localhost-gateway',
         description: 'Gateway for local cluster access',
+        enabled: true,
         namespace: 'ark-system',
         chartPath: `${REGISTRY_BASE}/localhost-gateway`,
         installArgs: [],
     },
 };
 /**
- * Get services that can be installed via Helm charts
+ * Get services that can be installed via Helm charts (only enabled services)
  */
 export function getInstallableServices() {
     const installable = {};
     for (const [key, service] of Object.entries(arkServices)) {
-        if (service.chartPath) {
+        if (service.enabled && service.chartPath) {
             installable[key] = service;
         }
     }
     return installable;
 }
-/**
- * Get services that can be checked for status
- */
-export function getStatusCheckableServices() {
-    const statusServices = {};
-    for (const [key, service] of Object.entries(arkServices)) {
-        if (service.gatewayUrl) {
-            statusServices[key] = service.gatewayUrl;
-        }
-    }
-    return statusServices;
-}
-/**
- * Get health check path for a specific service
- */
-export function getHealthPath(serviceName) {
-    const service = arkServices[serviceName];
-    return service?.healthPath || '';
-}

package/dist/arkServices.spec.d.ts

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

package/dist/arkServices.spec.js

@@ -0,0 +1,24 @@
+import { arkDependencies, arkServices, getInstallableServices, } from './arkServices.js';
+describe('arkServices', () => {
+    it('exports arkDependencies with expected structure', () => {
+        expect(arkDependencies).toBeDefined();
+        expect(arkDependencies['cert-manager']).toBeDefined();
+        expect(arkDependencies['cert-manager'].command).toBe('helm');
+    });
+    it('exports arkServices with expected structure', () => {
+        expect(arkServices).toBeDefined();
+        expect(arkServices['ark-controller']).toBeDefined();
+        expect(arkServices['ark-controller'].namespace).toBe('ark-system');
+        // User services should have undefined namespace (use current context)
+        expect(arkServices['ark-api'].namespace).toBeUndefined();
+        expect(arkServices['ark-dashboard'].namespace).toBeUndefined();
+        // System services should have explicit namespace
+        expect(arkServices['localhost-gateway'].namespace).toBe('ark-system');
+    });
+    it('getInstallableServices returns services with chartPath', () => {
+        const installable = getInstallableServices();
+        expect(installable['ark-controller']).toBeDefined();
+        expect(installable['ark-api']).toBeDefined();
+        expect(installable['ark-api-a2a']).toBeUndefined(); // no chartPath
+    });
+});

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

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

package/dist/commands/agents/index.js

@@ -25,16 +25,11 @@ async function listAgents(options) {
         }
     }
     catch (error) {
-        if (error instanceof Error && error.message.includes('the server doesn\'t have a resource type')) {
-            output.error('Agent CRDs not installed. Is the ARK controller running?');
-        }
-        else {
-            output.error('fetching agents:', error instanceof Error ? error.message : error);
-        }
+        output.error('fetching agents:', error instanceof Error ? error.message : error);
         process.exit(1);
     }
 }
-export function createAgentsCommand() {
+export function createAgentsCommand(_) {
     const agentsCommand = new Command('agents');
     agentsCommand
         .description('list available agents')

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

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

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

@@ -0,0 +1,67 @@
+import { jest } from '@jest/globals';
+import { Command } from 'commander';
+const mockExeca = jest.fn();
+jest.unstable_mockModule('execa', () => ({
+    execa: mockExeca,
+}));
+const mockOutput = {
+    warning: jest.fn(),
+    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 mockConsoleLog = jest.spyOn(console, 'log').mockImplementation(() => { });
+const { createAgentsCommand } = await import('./index.js');
+describe('agents command', () => {
+    beforeEach(() => {
+        jest.clearAllMocks();
+    });
+    it('creates command with correct structure', () => {
+        const command = createAgentsCommand({});
+        expect(command).toBeInstanceOf(Command);
+        expect(command.name()).toBe('agents');
+    });
+    it('lists agents in text format', async () => {
+        const mockAgents = {
+            items: [{ metadata: { name: 'agent1' } }, { metadata: { name: 'agent2' } }],
+        };
+        mockExeca.mockResolvedValue({ stdout: JSON.stringify(mockAgents) });
+        const command = createAgentsCommand({});
+        await command.parseAsync(['node', 'test']);
+        expect(mockExeca).toHaveBeenCalledWith('kubectl', ['get', 'agents', '-o', 'json'], { stdio: 'pipe' });
+        expect(mockConsoleLog).toHaveBeenCalledWith('agent1');
+        expect(mockConsoleLog).toHaveBeenCalledWith('agent2');
+    });
+    it('lists agents in json format', async () => {
+        const mockAgents = {
+            items: [{ metadata: { name: 'agent1' } }],
+        };
+        mockExeca.mockResolvedValue({ stdout: JSON.stringify(mockAgents) });
+        const command = createAgentsCommand({});
+        await command.parseAsync(['node', 'test', '-o', 'json']);
+        expect(mockConsoleLog).toHaveBeenCalledWith(JSON.stringify(mockAgents.items, null, 2));
+    });
+    it('shows warning when no agents', async () => {
+        mockExeca.mockResolvedValue({ stdout: JSON.stringify({ items: [] }) });
+        const command = createAgentsCommand({});
+        await command.parseAsync(['node', 'test']);
+        expect(mockOutput.warning).toHaveBeenCalledWith('no agents available');
+    });
+    it('handles errors', async () => {
+        mockExeca.mockRejectedValue(new Error('kubectl failed'));
+        const command = createAgentsCommand({});
+        await expect(command.parseAsync(['node', 'test'])).rejects.toThrow('process.exit called');
+        expect(mockOutput.error).toHaveBeenCalledWith('fetching agents:', 'kubectl failed');
+        expect(mockExit).toHaveBeenCalledWith(1);
+    });
+    it('list subcommand works', async () => {
+        mockExeca.mockResolvedValue({ stdout: JSON.stringify({ items: [] }) });
+        const command = createAgentsCommand({});
+        await command.parseAsync(['node', 'test', 'list']);
+        expect(mockExeca).toHaveBeenCalled();
+    });
+});

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

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

package/dist/commands/chat/index.js

@@ -3,32 +3,16 @@ import { Command } from 'commander';
 import { render } from 'ink';
 import ChatUI from '../../components/ChatUI.js';
 import { ArkApiProxy } from '../../lib/arkApiProxy.js';
-import { loadConfig } from '../../lib/config.js';
 import output from '../../lib/output.js';
-export function createChatCommand() {
+export function createChatCommand(config) {
     const chatCommand = new Command('chat');
     chatCommand
         .description('Start an interactive chat session with ARK agents or models')
         .argument('[target]', 'Target to connect to (e.g., agent/sample-agent, model/default)')
-        .option('-a, --agent <name>', 'Connect directly to a specific agent')
-        .option('-m, --model <name>', 'Connect directly to a specific model')
-        .action(async (targetArg, options) => {
-        // Determine initial target from argument or options
-        let initialTargetId;
-        if (targetArg) {
-            // Direct target argument (e.g., "agent/sample-agent")
-            initialTargetId = targetArg;
-        }
-        else if (options.agent) {
-            // Agent option
-            initialTargetId = `agent/${options.agent}`;
-        }
-        else if (options.model) {
-            // Model option
-            initialTargetId = `model/${options.model}`;
-        }
-        // Load config
-        const config = loadConfig();
+        .action(async (targetArg) => {
+        // Direct target argument (e.g., "agent/sample-agent")
+        const initialTargetId = targetArg;
+        // Config is passed from main
         // Initialize proxy first - no spinner, just let ChatUI handle loading state
         try {
             const proxy = new ArkApiProxy();

package/dist/commands/cluster/get.spec.d.ts

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

package/dist/commands/cluster/get.spec.js

@@ -0,0 +1,92 @@
+import { jest } from '@jest/globals';
+import { Command } from 'commander';
+const mockGetClusterInfo = jest.fn();
+jest.unstable_mockModule('../../lib/cluster.js', () => ({
+    getClusterInfo: mockGetClusterInfo,
+}));
+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 mockConsoleLog = jest.spyOn(console, 'log').mockImplementation(() => { });
+const { createGetCommand } = await import('./get.js');
+describe('cluster get command', () => {
+    beforeEach(() => {
+        jest.clearAllMocks();
+    });
+    it('creates command with correct structure', () => {
+        const command = createGetCommand();
+        expect(command).toBeInstanceOf(Command);
+        expect(command.name()).toBe('get');
+    });
+    it('displays cluster info in text format by default', async () => {
+        mockGetClusterInfo.mockResolvedValue({
+            context: 'test-cluster',
+            namespace: 'default',
+            type: 'minikube',
+            ip: '192.168.1.1',
+        });
+        const command = createGetCommand();
+        await command.parseAsync(['node', 'test']);
+        expect(mockGetClusterInfo).toHaveBeenCalledWith(undefined);
+        expect(mockConsoleLog).toHaveBeenCalledWith('context: test-cluster');
+        expect(mockConsoleLog).toHaveBeenCalledWith('namespace: default');
+        expect(mockConsoleLog).toHaveBeenCalledWith('type: minikube');
+        expect(mockConsoleLog).toHaveBeenCalledWith('ip: 192.168.1.1');
+    });
+    it('displays cluster info in json format when requested', async () => {
+        const clusterInfo = {
+            context: 'prod-cluster',
+            namespace: 'production',
+            type: 'eks',
+            ip: '10.0.0.1',
+        };
+        mockGetClusterInfo.mockResolvedValue(clusterInfo);
+        const command = createGetCommand();
+        await command.parseAsync(['node', 'test', '-o', 'json']);
+        expect(mockConsoleLog).toHaveBeenCalledWith(JSON.stringify(clusterInfo, null, 2));
+    });
+    it('uses specified context when provided', async () => {
+        mockGetClusterInfo.mockResolvedValue({
+            context: 'custom-context',
+            namespace: 'custom',
+            type: 'kind',
+            ip: '127.0.0.1',
+        });
+        const command = createGetCommand();
+        await command.parseAsync(['node', 'test', '-c', 'custom-context']);
+        expect(mockGetClusterInfo).toHaveBeenCalledWith('custom-context');
+    });
+    it('handles missing ip gracefully', async () => {
+        mockGetClusterInfo.mockResolvedValue({
+            context: 'test-cluster',
+            namespace: 'default',
+            type: 'unknown',
+            ip: undefined,
+        });
+        const command = createGetCommand();
+        await command.parseAsync(['node', 'test']);
+        expect(mockConsoleLog).toHaveBeenCalledWith('ip: unknown');
+    });
+    it('exits with error when cluster info has error', async () => {
+        mockGetClusterInfo.mockResolvedValue({
+            error: 'No cluster found',
+        });
+        const command = createGetCommand();
+        await expect(command.parseAsync(['node', 'test'])).rejects.toThrow('process.exit called');
+        expect(mockOutput.error).toHaveBeenCalledWith('getting cluster info:', 'No cluster found');
+        expect(mockExit).toHaveBeenCalledWith(1);
+    });
+    it('handles exceptions gracefully', async () => {
+        mockGetClusterInfo.mockRejectedValue(new Error('Connection failed'));
+        const command = createGetCommand();
+        await expect(command.parseAsync(['node', 'test'])).rejects.toThrow('process.exit called');
+        expect(mockOutput.error).toHaveBeenCalledWith('failed to get cluster info:', 'Connection failed');
+        expect(mockExit).toHaveBeenCalledWith(1);
+    });
+});

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

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

package/dist/commands/cluster/index.js

@@ -1,6 +1,6 @@
 import { Command } from 'commander';
 import { createGetCommand } from './get.js';
-export function createClusterCommand() {
+export function createClusterCommand(_) {
     const cluster = new Command('cluster');
     cluster.description('Cluster management commands');
     cluster.addCommand(createGetCommand());

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

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

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

@@ -0,0 +1,24 @@
+import { jest } from '@jest/globals';
+import { Command } from 'commander';
+const mockCreateGetCommand = jest.fn();
+jest.unstable_mockModule('./get.js', () => ({
+    createGetCommand: mockCreateGetCommand,
+}));
+const { createClusterCommand } = await import('./index.js');
+describe('cluster command', () => {
+    beforeEach(() => {
+        jest.clearAllMocks();
+        mockCreateGetCommand.mockReturnValue(new Command('get'));
+    });
+    it('creates command with correct structure', () => {
+        const command = createClusterCommand({});
+        expect(command).toBeInstanceOf(Command);
+        expect(command.name()).toBe('cluster');
+    });
+    it('adds get subcommand', () => {
+        const command = createClusterCommand({});
+        expect(mockCreateGetCommand).toHaveBeenCalled();
+        const getCommand = command.commands.find((cmd) => cmd.name() === 'get');
+        expect(getCommand).toBeDefined();
+    });
+});

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

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

package/dist/commands/completion/index.js

@@ -1,6 +1,6 @@
 import chalk from 'chalk';
 import { Command } from 'commander';
-export function createCompletionCommand() {
+export function createCompletionCommand(_) {
     const completion = new Command('completion');
     completion.description('Generate shell completion scripts').action(() => {
         console.log(chalk.cyan('Shell completion for ARK CLI'));
@@ -28,7 +28,7 @@ _ark_completion() {
   
   case \${COMP_CWORD} in
     1)
-      opts="agents chat cluster completion config dashboard dev generate install models routes status targets teams tools uninstall help"
+      opts="agents chat cluster completion config dashboard dev docs generate install models query routes status targets teams tools uninstall help"
       COMPREPLY=( $(compgen -W "\${opts}" -- \${cur}) )
       return 0
       ;;
@@ -95,6 +95,17 @@ _ark_completion() {
           COMPREPLY=( $(compgen -W "\${targets}" -- \${cur}) )
           return 0
           ;;
+        query)
+          # Dynamically fetch available targets for query command
+          local targets
+          targets=$(ark targets list 2>/dev/null)
+          if [ -z "$targets" ]; then
+            # Fallback to common targets if API is not available
+            targets="model/default agent/sample-agent"
+          fi
+          COMPREPLY=( $(compgen -W "\${targets}" -- \${cur}) )
+          return 0
+          ;;
       esac
       ;;
     3)
@@ -159,9 +170,11 @@ _ark() {
         'config[Configuration management]' \\
         'dashboard[Open ARK dashboard]' \\
         'dev[Development tools for ARK]' \\
+        'docs[Open ARK documentation]' \\
         'generate[Generate ARK resources]' \\
         'install[Install ARK services]' \\
         'models[List available models]' \\
+        'query[Execute a single query]' \\
         'routes[List available routes]' \\
         'status[Check system status]' \\
         'targets[List available query targets]' \\
@@ -234,6 +247,15 @@ _ark() {
           fi
           _values 'available targets' \${targets[@]}
           ;;
+        query)
+          # Get available targets dynamically for query
+          local -a targets
+          targets=($(ark targets list 2>/dev/null))
+          if [ \${#targets[@]} -eq 0 ]; then
+            targets=('model/default' 'agent/sample-agent')
+          fi
+          _values 'available targets' \${targets[@]}
+          ;;
       esac
       ;;
     args)

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

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

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

@@ -0,0 +1,34 @@
+import { jest } from '@jest/globals';
+import { Command } from 'commander';
+const mockConsoleLog = jest.spyOn(console, 'log').mockImplementation(() => { });
+const { createCompletionCommand } = await import('./index.js');
+describe('completion command', () => {
+    beforeEach(() => {
+        jest.clearAllMocks();
+    });
+    it('creates command with correct structure', () => {
+        const command = createCompletionCommand({});
+        expect(command).toBeInstanceOf(Command);
+        expect(command.name()).toBe('completion');
+    });
+    it('shows help when called without subcommand', async () => {
+        const command = createCompletionCommand({});
+        await command.parseAsync(['node', 'test']);
+        // Check first call contains the title (strip ANSI color codes)
+        expect(mockConsoleLog.mock.calls[0][0]).toContain('Shell completion for ARK CLI');
+        // Check that bash completion instructions are shown
+        expect(mockConsoleLog).toHaveBeenCalledWith(expect.stringContaining('ark completion bash'));
+    });
+    it('outputs bash completion script', async () => {
+        const command = createCompletionCommand({});
+        await command.parseAsync(['node', 'test', 'bash']);
+        expect(mockConsoleLog).toHaveBeenCalledWith(expect.stringContaining('_ark_completion()'));
+        expect(mockConsoleLog).toHaveBeenCalledWith(expect.stringContaining('COMPREPLY'));
+    });
+    it('outputs zsh completion script', async () => {
+        const command = createCompletionCommand({});
+        await command.parseAsync(['node', 'test', 'zsh']);
+        expect(mockConsoleLog).toHaveBeenCalledWith(expect.stringContaining('#compdef ark'));
+        expect(mockConsoleLog).toHaveBeenCalledWith(expect.stringContaining('_ark()'));
+    });
+});

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

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

package/dist/commands/config/index.js

@@ -1,8 +1,8 @@
 import { Command } from 'commander';
 import chalk from 'chalk';
-import { loadConfig, getConfigPaths, formatConfig } from '../../lib/config.js';
+import { loadConfig, getConfigPaths, formatConfig, } from '../../lib/config.js';
 import fs from 'fs';
-export function createConfigCommand() {
+export function createConfigCommand(_) {
     const configCommand = new Command('config');
     configCommand.description('Show current configuration').action(() => {
         const config = loadConfig();

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

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