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

package/dist/commands/chat.js

@@ -0,0 +1,45 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+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() {
+    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();
+        // Initialize proxy first - no spinner, just let ChatUI handle loading state
+        try {
+            const proxy = new ArkApiProxy();
+            const arkApiClient = await proxy.start();
+            // Pass the initialized client and config to ChatUI
+            render(_jsx(ChatUI, { initialTargetId: initialTargetId, arkApiClient: arkApiClient, arkApiProxy: proxy, config: config }));
+        }
+        catch (error) {
+            output.error(error instanceof Error ? error.message : 'ARK API connection failed');
+            process.exit(1);
+        }
+    });
+    return chatCommand;
+}

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

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export declare function createGetCommand(): Command;

package/dist/commands/cluster/get.js

@@ -0,0 +1,39 @@
+import { Command } from 'commander';
+import output from '../../lib/output.js';
+import { getClusterInfo } from '../../lib/cluster.js';
+export function createGetCommand() {
+    const get = new Command('get');
+    get
+        .description('get current kubernetes cluster information')
+        .option('-c, --context <context>', 'kubernetes context to use')
+        .option('-o, --output <format>', 'output format (text|json)', 'text')
+        .action(async (options) => {
+        try {
+            const clusterInfo = await getClusterInfo(options.context);
+            if (clusterInfo.error) {
+                output.error('getting cluster info:', clusterInfo.error);
+                process.exit(1);
+            }
+            if (options.output === 'json') {
+                console.log(JSON.stringify({
+                    context: clusterInfo.context,
+                    namespace: clusterInfo.namespace,
+                    type: clusterInfo.type,
+                    ip: clusterInfo.ip,
+                }, null, 2));
+            }
+            else {
+                // Text format (default)
+                console.log(`context: ${clusterInfo.context}`);
+                console.log(`namespace: ${clusterInfo.namespace}`);
+                console.log(`type: ${clusterInfo.type}`);
+                console.log(`ip: ${clusterInfo.ip || 'unknown'}`);
+            }
+        }
+        catch (error) {
+            output.error('failed to get cluster info:', error instanceof Error ? error.message : 'Unknown error');
+            process.exit(1);
+        }
+    });
+    return get;
+}

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,10 +1,8 @@
 import { Command } from 'commander';
-import { createGetIpCommand } from './get-ip.js';
-import { createGetTypeCommand } from './get-type.js';
-export function createClusterCommand() {
+import { createGetCommand } from './get.js';
+export function createClusterCommand(_) {
     const cluster = new Command('cluster');
     cluster.description('Cluster management commands');
-    cluster.addCommand(createGetTypeCommand());
-    cluster.addCommand(createGetIpCommand());
+    cluster.addCommand(createGetCommand());
     return cluster;
 }

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

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

package/dist/commands/completion/index.js

@@ -0,0 +1,230 @@
+import chalk from 'chalk';
+import { Command } from 'commander';
+export function createCompletionCommand(_) {
+    const completion = new Command('completion');
+    completion.description('Generate shell completion scripts').action(() => {
+        console.log(chalk.cyan('Shell completion for ARK CLI'));
+        console.log('');
+        console.log('Usage:');
+        console.log('  ark completion bash   Generate bash completion script');
+        console.log('  ark completion zsh    Generate zsh completion script');
+        console.log('');
+        console.log('To enable completion, add this to your shell profile:');
+        console.log(chalk.grey('  # For bash:'));
+        console.log(chalk.grey('  eval "$(ark completion bash)"'));
+        console.log(chalk.grey('  # For zsh:'));
+        console.log(chalk.grey('  eval "$(ark completion zsh)"'));
+    });
+    completion
+        .command('bash')
+        .description('Generate bash completion script')
+        .action(() => {
+        console.log(`
+_ark_completion() {
+  local cur prev opts
+  COMPREPLY=()
+  cur="\${COMP_WORDS[COMP_CWORD]}"
+  prev="\${COMP_WORDS[COMP_CWORD-1]}"
+  
+  case \${COMP_CWORD} in
+    1)
+      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
+      ;;
+    2)
+      case \${prev} in
+        cluster)
+          opts="get-ip get-type"
+          COMPREPLY=( $(compgen -W "\${opts}" -- \${cur}) )
+          return 0
+          ;;
+        completion)
+          opts="bash zsh"
+          COMPREPLY=( $(compgen -W "\${opts}" -- \${cur}) )
+          return 0
+          ;;
+        check)
+          opts="status"
+          COMPREPLY=( $(compgen -W "\${opts}" -- \${cur}) )
+          return 0
+          ;;
+        targets)
+          opts="list ls"
+          COMPREPLY=( $(compgen -W "\${opts}" -- \${cur}) )
+          return 0
+          ;;
+        agents)
+          opts="list ls"
+          COMPREPLY=( $(compgen -W "\${opts}" -- \${cur}) )
+          return 0
+          ;;
+        models)
+          opts="list ls create"
+          COMPREPLY=( $(compgen -W "\${opts}" -- \${cur}) )
+          return 0
+          ;;
+        teams)
+          opts="list ls"
+          COMPREPLY=( $(compgen -W "\${opts}" -- \${cur}) )
+          return 0
+          ;;
+        tools)
+          opts="list ls"
+          COMPREPLY=( $(compgen -W "\${opts}" -- \${cur}) )
+          return 0
+          ;;
+        generate)
+          opts="agent marketplace mcp-server project query team"
+          COMPREPLY=( $(compgen -W "\${opts}" -- \${cur}) )
+          return 0
+          ;;
+        chat)
+          # Dynamically fetch available targets using ark targets list
+          local targets
+          targets=$(ark targets list 2>/dev/null)
+          if [ -z "$targets" ]; then
+            # Fallback to common targets if API is not available
+            targets="agent/sample-agent agent/math agent/weather model/default"
+          fi
+          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
+      ;;
+  esac
+}
+
+complete -F _ark_completion ark
+      `.trim());
+    });
+    completion
+        .command('zsh')
+        .description('Generate zsh completion script')
+        .action(() => {
+        // Shell script requires escaped $ characters
+        /* eslint-disable no-useless-escape */
+        console.log(`
+#compdef ark
+
+_ark() {
+  local context state line
+  
+  _arguments -C \\
+    '1:command:->command' \\
+    '2:subcommand:->subcommand' \\
+    '*::arg:->args'
+    
+  case $state in
+    command)
+      _values 'ark commands' \\
+        'agents[List available agents]' \\
+        'chat[Interactive chat with agents and models]' \\
+        'cluster[Cluster management commands]' \\
+        'completion[Generate shell completion scripts]' \\
+        'config[Configuration management]' \\
+        'dashboard[Open ARK dashboard]' \\
+        '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]' \\
+        'teams[List available teams]' \\
+        'tools[List available tools]' \\
+        'uninstall[Uninstall ARK services]' \\
+        'help[Show help information]'
+      ;;
+    subcommand)
+      case $words[2] in
+        cluster)
+          _values 'cluster commands' \\
+            'get-ip[Get cluster IP address]' \\
+            'get-type[Get cluster type]'
+          ;;
+        completion)
+          _values 'completion shells' \\
+            'bash[Generate bash completion]' \\
+            'zsh[Generate zsh completion]'
+          ;;
+        check)
+          _values 'check commands' \\
+            'status[Check system status]'
+          ;;
+        targets)
+          _values 'targets commands' \\
+            'list[List all available targets]' \\
+            'ls[List all available targets]'
+          ;;
+        agents)
+          _values 'agents commands' \\
+            'list[List all available agents]' \\
+            'ls[List all available agents]'
+          ;;
+        models)
+          _values 'models commands' \\
+            'list[List all available models]' \\
+            'ls[List all available models]' \\
+            'create[Create a new model]'
+          ;;
+        teams)
+          _values 'teams commands' \\
+            'list[List all available teams]' \\
+            'ls[List all available teams]'
+          ;;
+        tools)
+          _values 'tools commands' \\
+            'list[List all available tools]' \\
+            'ls[List all available tools]'
+          ;;
+        generate)
+          _values 'generate types' \\
+            'agent[Generate a new agent]' \\
+            'marketplace[Generate marketplace content]' \\
+            'mcp-server[Generate MCP server]' \\
+            'project[Generate a new project]' \\
+            'query[Generate a query]' \\
+            'team[Generate a team]'
+          ;;
+        chat)
+          # Get available targets dynamically
+          local -a targets
+          targets=($(ark targets list 2>/dev/null))
+          if [ \${#targets[@]} -eq 0 ]; then
+            targets=('agent/sample-agent' 'agent/math' 'agent/weather' 'model/default')
+          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
+      ;;
+  esac
+}
+
+_ark
+      `.trim());
+        /* eslint-enable no-useless-escape */
+    });
+    return completion;
+}

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()'));
+    });
+});