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

package/dist/commands/targets/index.js

@@ -1,34 +1,46 @@
 import { Command } from 'commander';
+import { execa } from 'execa';
 import output from '../../lib/output.js';
-import { ArkApiProxy } from '../../lib/arkApiProxy.js';
+async function fetchResourceTargets(resourceType) {
+    const result = await execa('kubectl', ['get', `${resourceType}s`, '-o', 'json'], {
+        stdio: 'pipe',
+    });
+    const data = JSON.parse(result.stdout);
+    const items = data.items || [];
+    return items.map((item) => ({
+        type: resourceType,
+        name: item.metadata.name,
+        id: `${resourceType}/${item.metadata.name}`,
+        available: item.status?.available || item.status?.phase === 'ready' || true,
+    }));
+}
 async function listTargets(options) {
-    let proxy;
     try {
-        proxy = new ArkApiProxy();
-        const arkApiClient = await proxy.start();
-        const allTargets = await arkApiClient.getQueryTargets();
-        // Filter by type if specified
-        let filteredTargets = allTargets;
-        if (options.type) {
-            filteredTargets = allTargets.filter((t) => t.type === options.type);
-        }
+        // Fetch all resource types in parallel
+        const resourceTypes = options.type
+            ? [options.type]
+            : ['model', 'agent', 'team', 'tool'];
+        const targetPromises = resourceTypes.map((type) => fetchResourceTargets(type));
+        const targetArrays = await Promise.all(targetPromises);
+        // Flatten all targets into single array
+        const allTargets = targetArrays.flat();
         // Sort targets by type and name
-        filteredTargets.sort((a, b) => {
+        allTargets.sort((a, b) => {
             if (a.type !== b.type) {
                 return a.type.localeCompare(b.type);
             }
             return a.name.localeCompare(b.name);
         });
         if (options.output === 'json') {
-            console.log(JSON.stringify(filteredTargets, null, 2));
+            console.log(JSON.stringify(allTargets, null, 2));
         }
         else {
-            if (filteredTargets.length === 0) {
+            if (allTargets.length === 0) {
                 output.warning('no targets available');
                 return;
             }
             // Simple list output with type/name format
-            for (const target of filteredTargets) {
+            for (const target of allTargets) {
                 console.log(target.id);
             }
         }
@@ -37,11 +49,6 @@ async function listTargets(options) {
         output.error('fetching targets:', error instanceof Error ? error.message : error);
         process.exit(1);
     }
-    finally {
-        if (proxy) {
-            proxy.stop();
-        }
-    }
 }
 export function createTargetsCommand(_) {
     const targets = new Command('targets');

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

@@ -1,17 +1,8 @@
 import { jest } from '@jest/globals';
 import { Command } from 'commander';
-const mockArkApiClient = {
-    getQueryTargets: jest.fn(),
-};
-const mockStart = jest.fn();
-mockStart.mockResolvedValue(mockArkApiClient);
-const mockArkApiProxy = jest.fn();
-mockArkApiProxy.prototype = {
-    start: mockStart,
-    stop: jest.fn(),
-};
-jest.unstable_mockModule('../../lib/arkApiProxy.js', () => ({
-    ArkApiProxy: mockArkApiProxy,
+// Mock execa to avoid real kubectl calls
+jest.unstable_mockModule('execa', () => ({
+    execa: jest.fn(),
 }));
 const mockOutput = {
     warning: jest.fn(),
@@ -24,6 +15,8 @@ const mockExit = jest.spyOn(process, 'exit').mockImplementation((() => {
     throw new Error('process.exit called');
 }));
 const mockConsoleLog = jest.spyOn(console, 'log').mockImplementation(() => { });
+const { execa } = await import('execa');
+const mockExeca = execa;
 const { createTargetsCommand } = await import('./index.js');
 describe('targets command', () => {
     beforeEach(() => {
@@ -35,71 +28,127 @@ describe('targets command', () => {
         expect(command.name()).toBe('targets');
     });
     it('lists targets in text format', async () => {
-        const mockTargets = [
-            { id: 'agent/gpt-assistant', type: 'agent', name: 'gpt-assistant' },
-            { id: 'model/gpt-4', type: 'model', name: 'gpt-4' },
-        ];
-        mockArkApiClient.getQueryTargets.mockResolvedValue(mockTargets);
+        // Mock kubectl responses for each resource type (order: model, agent, team, tool)
+        mockExeca
+            .mockResolvedValueOnce({
+            stdout: JSON.stringify({
+                items: [{ metadata: { name: 'gpt-4' }, status: { available: true } }],
+            }),
+        })
+            .mockResolvedValueOnce({
+            stdout: JSON.stringify({
+                items: [
+                    { metadata: { name: 'gpt-assistant' }, status: { phase: 'ready' } },
+                ],
+            }),
+        })
+            .mockResolvedValueOnce({ stdout: JSON.stringify({ items: [] }) })
+            .mockResolvedValueOnce({ stdout: JSON.stringify({ items: [] }) });
         const command = createTargetsCommand({});
         await command.parseAsync(['node', 'test']);
-        expect(mockArkApiProxy.prototype.start).toHaveBeenCalled();
-        expect(mockArkApiClient.getQueryTargets).toHaveBeenCalled();
+        expect(mockExeca).toHaveBeenCalledWith('kubectl', ['get', 'models', '-o', 'json'], {
+            stdio: 'pipe',
+        });
+        expect(mockExeca).toHaveBeenCalledWith('kubectl', ['get', 'agents', '-o', 'json'], {
+            stdio: 'pipe',
+        });
         expect(mockConsoleLog).toHaveBeenCalledWith('agent/gpt-assistant');
         expect(mockConsoleLog).toHaveBeenCalledWith('model/gpt-4');
-        expect(mockArkApiProxy.prototype.stop).toHaveBeenCalled();
     });
     it('lists targets in json format', async () => {
-        const mockTargets = [{ id: 'agent/gpt', type: 'agent', name: 'gpt' }];
-        mockArkApiClient.getQueryTargets.mockResolvedValue(mockTargets);
+        // Order: model, agent, team, tool
+        mockExeca
+            .mockResolvedValueOnce({ stdout: JSON.stringify({ items: [] }) })
+            .mockResolvedValueOnce({
+            stdout: JSON.stringify({
+                items: [{ metadata: { name: 'gpt' }, status: { phase: 'ready' } }],
+            }),
+        })
+            .mockResolvedValueOnce({ stdout: JSON.stringify({ items: [] }) })
+            .mockResolvedValueOnce({ stdout: JSON.stringify({ items: [] }) });
         const command = createTargetsCommand({});
         await command.parseAsync(['node', 'test', '-o', 'json']);
-        expect(mockConsoleLog).toHaveBeenCalledWith(JSON.stringify(mockTargets, null, 2));
+        const expectedTargets = [
+            { type: 'agent', name: 'gpt', id: 'agent/gpt', available: true },
+        ];
+        expect(mockConsoleLog).toHaveBeenCalledWith(JSON.stringify(expectedTargets, null, 2));
     });
     it('filters targets by type', async () => {
-        const mockTargets = [
-            { id: 'agent/gpt', type: 'agent', name: 'gpt' },
-            { id: 'model/claude', type: 'model', name: 'claude' },
-            { id: 'agent/helper', type: 'agent', name: 'helper' },
-        ];
-        mockArkApiClient.getQueryTargets.mockResolvedValue(mockTargets);
+        mockExeca.mockResolvedValueOnce({
+            stdout: JSON.stringify({
+                items: [
+                    { metadata: { name: 'gpt' }, status: { phase: 'ready' } },
+                    { metadata: { name: 'helper' }, status: { phase: 'ready' } },
+                ],
+            }),
+        });
         const command = createTargetsCommand({});
         await command.parseAsync(['node', 'test', '-t', 'agent']);
+        expect(mockExeca).toHaveBeenCalledWith('kubectl', ['get', 'agents', '-o', 'json'], {
+            stdio: 'pipe',
+        });
+        expect(mockExeca).toHaveBeenCalledTimes(1); // Only agents, not other types
         expect(mockConsoleLog).toHaveBeenCalledWith('agent/gpt');
         expect(mockConsoleLog).toHaveBeenCalledWith('agent/helper');
-        expect(mockConsoleLog).not.toHaveBeenCalledWith('model/claude');
     });
     it('sorts targets by type then name', async () => {
-        const mockTargets = [
-            { id: 'model/b', type: 'model', name: 'b' },
-            { id: 'agent/z', type: 'agent', name: 'z' },
-            { id: 'agent/a', type: 'agent', name: 'a' },
-            { id: 'model/a', type: 'model', name: 'a' },
-        ];
-        mockArkApiClient.getQueryTargets.mockResolvedValue(mockTargets);
+        // Order: model, agent, team, tool
+        mockExeca
+            .mockResolvedValueOnce({
+            stdout: JSON.stringify({
+                items: [
+                    { metadata: { name: 'b' }, status: { available: true } },
+                    { metadata: { name: 'a' }, status: { available: true } },
+                ],
+            }),
+        })
+            .mockResolvedValueOnce({
+            stdout: JSON.stringify({
+                items: [
+                    { metadata: { name: 'z' }, status: { phase: 'ready' } },
+                    { metadata: { name: 'a' }, status: { phase: 'ready' } },
+                ],
+            }),
+        })
+            .mockResolvedValueOnce({ stdout: JSON.stringify({ items: [] }) })
+            .mockResolvedValueOnce({ stdout: JSON.stringify({ items: [] }) });
         const command = createTargetsCommand({});
         await command.parseAsync(['node', 'test']);
-        // Check order of calls
-        const calls = mockConsoleLog.mock.calls.map((call) => call[0]);
+        // Check order of calls - sorted by type then name
+        const calls = mockConsoleLog.mock.calls
+            .filter((call) => call[0] && call[0].includes('/'))
+            .map((call) => call[0]);
         expect(calls).toEqual(['agent/a', 'agent/z', 'model/a', 'model/b']);
     });
     it('shows warning when no targets', async () => {
-        mockArkApiClient.getQueryTargets.mockResolvedValue([]);
+        // All resource types return empty (order: model, agent, team, tool)
+        mockExeca
+            .mockResolvedValueOnce({ stdout: JSON.stringify({ items: [] }) })
+            .mockResolvedValueOnce({ stdout: JSON.stringify({ items: [] }) })
+            .mockResolvedValueOnce({ stdout: JSON.stringify({ items: [] }) })
+            .mockResolvedValueOnce({ stdout: JSON.stringify({ items: [] }) });
         const command = createTargetsCommand({});
         await command.parseAsync(['node', 'test']);
         expect(mockOutput.warning).toHaveBeenCalledWith('no targets available');
     });
-    it('handles errors and stops proxy', async () => {
-        mockArkApiClient.getQueryTargets.mockRejectedValue(new Error('API failed'));
+    it('handles errors', async () => {
+        mockExeca.mockRejectedValue(new Error('kubectl not found'));
         const command = createTargetsCommand({});
         await expect(command.parseAsync(['node', 'test'])).rejects.toThrow('process.exit called');
-        expect(mockOutput.error).toHaveBeenCalledWith('fetching targets:', 'API failed');
+        expect(mockOutput.error).toHaveBeenCalledWith('fetching targets:', 'kubectl not found');
         expect(mockExit).toHaveBeenCalledWith(1);
-        expect(mockArkApiProxy.prototype.stop).toHaveBeenCalled();
     });
     it('list subcommand works', async () => {
-        mockArkApiClient.getQueryTargets.mockResolvedValue([]);
+        // Order: model, agent, team, tool
+        mockExeca
+            .mockResolvedValueOnce({ stdout: JSON.stringify({ items: [] }) })
+            .mockResolvedValueOnce({ stdout: JSON.stringify({ items: [] }) })
+            .mockResolvedValueOnce({ stdout: JSON.stringify({ items: [] }) })
+            .mockResolvedValueOnce({ stdout: JSON.stringify({ items: [] }) });
         const command = createTargetsCommand({});
         await command.parseAsync(['node', 'test', 'list']);
-        expect(mockArkApiClient.getQueryTargets).toHaveBeenCalled();
+        expect(mockExeca).toHaveBeenCalledWith('kubectl', ['get', 'models', '-o', 'json'], {
+            stdio: 'pipe',
+        });
     });
 });

package/dist/commands/teams/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 listTeams(options) {
     try {
         // Use kubectl to get teams
@@ -45,5 +46,19 @@ export function createTeamsCommand(_) {
         await listTeams(options);
     });
     teamsCommand.addCommand(listCommand);
+    // Add query command
+    const queryCommand = new Command('query');
+    queryCommand
+        .description('Query a team')
+        .argument('<name>', 'Team name')
+        .argument('<message>', 'Message to send')
+        .action(async (name, message) => {
+        await executeQuery({
+            targetType: 'team',
+            targetName: name,
+            message,
+        });
+    });
+    teamsCommand.addCommand(queryCommand);
     return teamsCommand;
 }

package/dist/commands/uninstall/index.js

@@ -22,11 +22,6 @@ async function uninstallArk(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, uninstall only that service
     if (serviceName) {

package/dist/components/statusChecker.d.ts

@@ -1,4 +1,4 @@
-import { StatusData, CommandVersionConfig } from '../lib/types.js';
+import { StatusData, CommandVersionConfig, ClusterInfo } from '../lib/types.js';
 export declare const getNodeVersion: () => CommandVersionConfig;
 export declare const getNpmVersion: () => CommandVersionConfig;
 export declare const getKubectlVersion: () => CommandVersionConfig;
@@ -33,6 +33,6 @@ export declare class StatusChecker {
      */
     checkAll(): Promise<StatusData & {
         clusterAccess: boolean;
-        clusterInfo?: any;
+        clusterInfo?: ClusterInfo;
     }>;
 }

package/dist/index.js

@@ -13,7 +13,6 @@ import { createClusterCommand } from './commands/cluster/index.js';
 import { createCompletionCommand } from './commands/completion/index.js';
 import { createDashboardCommand } from './commands/dashboard/index.js';
 import { createDocsCommand } from './commands/docs/index.js';
-import { createDevCommand } from './commands/dev/index.js';
 import { createGenerateCommand } from './commands/generate/index.js';
 import { createInstallCommand } from './commands/install/index.js';
 import { createModelsCommand } from './commands/models/index.js';
@@ -44,13 +43,12 @@ async function main() {
     program.addCommand(createCompletionCommand(config));
     program.addCommand(createDashboardCommand(config));
     program.addCommand(createDocsCommand(config));
-    program.addCommand(createDevCommand(config));
     program.addCommand(createGenerateCommand(config));
     program.addCommand(createInstallCommand(config));
     program.addCommand(createModelsCommand(config));
     program.addCommand(createQueryCommand(config));
     program.addCommand(createUninstallCommand(config));
-    program.addCommand(createStatusCommand(config));
+    program.addCommand(createStatusCommand());
     program.addCommand(createConfigCommand(config));
     program.addCommand(createTargetsCommand(config));
     program.addCommand(createTeamsCommand(config));

package/dist/lib/chatClient.js

@@ -10,90 +10,84 @@ export class ChatClient {
      */
     async sendMessage(targetId, messages, config, onChunk, signal) {
         const shouldStream = config.streamingEnabled && !!onChunk;
-        try {
-            const params = {
-                model: targetId,
-                messages: messages,
-                signal: signal,
-            };
-            if (shouldStream) {
-                let fullResponse = '';
-                const toolCallsById = new Map();
-                const stream = this.arkApiClient.createChatCompletionStream(params);
-                for await (const chunk of stream) {
-                    if (signal?.aborted) {
-                        break;
+        const params = {
+            model: targetId,
+            messages: messages,
+            signal: signal,
+        };
+        if (shouldStream) {
+            let fullResponse = '';
+            const toolCallsById = new Map();
+            const stream = this.arkApiClient.createChatCompletionStream(params);
+            for await (const chunk of stream) {
+                if (signal?.aborted) {
+                    break;
+                }
+                const delta = chunk.choices[0]?.delta;
+                // Extract ARK metadata if present
+                const arkMetadata = chunk.ark;
+                // Handle regular content
+                const content = delta?.content || '';
+                if (content) {
+                    fullResponse += content;
+                    if (onChunk) {
+                        onChunk(content, undefined, arkMetadata);
                     }
-                    const delta = chunk.choices[0]?.delta;
-                    // Extract ARK metadata if present
-                    const arkMetadata = chunk.ark;
-                    // Handle regular content
-                    const content = delta?.content || '';
-                    if (content) {
-                        fullResponse += content;
-                        if (onChunk) {
-                            onChunk(content, undefined, arkMetadata);
+                }
+                // Handle tool calls
+                if (delta?.tool_calls) {
+                    for (const toolCallDelta of delta.tool_calls) {
+                        const index = toolCallDelta.index;
+                        // Initialize tool call if this is the first chunk for this index
+                        if (!toolCallsById.has(index)) {
+                            toolCallsById.set(index, {
+                                id: toolCallDelta.id || '',
+                                type: toolCallDelta.type || 'function',
+                                function: {
+                                    name: toolCallDelta.function?.name || '',
+                                    arguments: '',
+                                },
+                            });
                         }
-                    }
-                    // Handle tool calls
-                    if (delta?.tool_calls) {
-                        for (const toolCallDelta of delta.tool_calls) {
-                            const index = toolCallDelta.index;
-                            // Initialize tool call if this is the first chunk for this index
-                            if (!toolCallsById.has(index)) {
-                                toolCallsById.set(index, {
-                                    id: toolCallDelta.id || '',
-                                    type: toolCallDelta.type || 'function',
-                                    function: {
-                                        name: toolCallDelta.function?.name || '',
-                                        arguments: '',
-                                    },
-                                });
-                            }
-                            // Accumulate function arguments
-                            const toolCall = toolCallsById.get(index);
-                            if (toolCallDelta.function?.arguments) {
-                                toolCall.function.arguments += toolCallDelta.function.arguments;
-                            }
-                            // Send the current state of all tool calls
-                            if (onChunk) {
-                                const toolCallsArray = Array.from(toolCallsById.values());
-                                onChunk('', toolCallsArray, arkMetadata);
-                            }
+                        // Accumulate function arguments
+                        const toolCall = toolCallsById.get(index);
+                        if (toolCallDelta.function?.arguments) {
+                            toolCall.function.arguments += toolCallDelta.function.arguments;
+                        }
+                        // Send the current state of all tool calls
+                        if (onChunk) {
+                            const toolCallsArray = Array.from(toolCallsById.values());
+                            onChunk('', toolCallsArray, arkMetadata);
                         }
                     }
                 }
-                return fullResponse;
             }
-            else {
-                const response = await this.arkApiClient.createChatCompletion(params);
-                const message = response.choices[0]?.message;
-                const content = message?.content || '';
-                // Handle tool calls in non-streaming mode
-                if (message?.tool_calls && message.tool_calls.length > 0) {
-                    const toolCalls = message.tool_calls.map((tc) => ({
-                        id: tc.id,
-                        type: tc.type || 'function',
-                        function: {
-                            name: tc.function?.name || '',
-                            arguments: tc.function?.arguments || '',
-                        },
-                    }));
-                    // Send tool calls first
-                    if (onChunk) {
-                        onChunk('', toolCalls);
-                    }
-                }
-                // Send content after tool calls
-                if (content && onChunk) {
-                    onChunk(content);
+            return fullResponse;
+        }
+        else {
+            const response = await this.arkApiClient.createChatCompletion(params);
+            const message = response.choices[0]?.message;
+            const content = message?.content || '';
+            // Handle tool calls in non-streaming mode
+            if (message?.tool_calls && message.tool_calls.length > 0) {
+                const toolCalls = message.tool_calls.map((tc) => ({
+                    id: tc.id,
+                    type: tc.type || 'function',
+                    function: {
+                        name: tc.function?.name || '',
+                        arguments: tc.function?.arguments || '',
+                    },
+                }));
+                // Send tool calls first
+                if (onChunk) {
+                    onChunk('', toolCalls);
                 }
-                return content;
             }
-        }
-        catch (error) {
-            // Don't log here - error will be displayed in the message thread
-            throw error;
+            // Send content after tool calls
+            if (content && onChunk) {
+                onChunk(content);
+            }
+            return content;
         }
     }
 }

package/dist/lib/config.d.ts

@@ -5,8 +5,6 @@ export interface ChatConfig {
 }
 export interface ArkConfig {
     chat?: ChatConfig;
-    latestVersion?: string;
-    currentVersion?: string;
     clusterInfo?: ClusterInfo;
 }
 /**

package/dist/lib/executeQuery.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Shared query execution logic for both universal and resource-specific query commands
+ */
+import type { QueryTarget } from './types.js';
+export interface QueryOptions {
+    targetType: string;
+    targetName: string;
+    message: string;
+    verbose?: boolean;
+}
+/**
+ * Execute a query against any ARK target (model, agent, team)
+ * This is the shared implementation used by all query commands
+ */
+export declare function executeQuery(options: QueryOptions): Promise<void>;
+/**
+ * Parse a target string like "model/default" or "agent/weather"
+ * Returns QueryTarget or null if invalid
+ */
+export declare function parseTarget(target: string): QueryTarget | null;