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

package/dist/commands/targets/index.js

@@ -0,0 +1,72 @@
+import { Command } from 'commander';
+import { execa } from 'execa';
+import output from '../../lib/output.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) {
+    try {
+        // 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
+        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(allTargets, null, 2));
+        }
+        else {
+            if (allTargets.length === 0) {
+                output.warning('no targets available');
+                return;
+            }
+            // Simple list output with type/name format
+            for (const target of allTargets) {
+                console.log(target.id);
+            }
+        }
+    }
+    catch (error) {
+        output.error('fetching targets:', error instanceof Error ? error.message : error);
+        process.exit(1);
+    }
+}
+export function createTargetsCommand(_) {
+    const targets = new Command('targets');
+    targets
+        .description('list available query targets (agents, teams, models, tools)')
+        .option('-o, --output <format>', 'output format (json or text)', 'text')
+        .option('-t, --type <type>', 'filter by type (agent, team, model, tool)')
+        .action(async (options) => {
+        await listTargets(options);
+    });
+    targets
+        .command('list')
+        .alias('ls')
+        .description('list all available query targets')
+        .option('-o, --output <format>', 'output format (json or text)', 'text')
+        .option('-t, --type <type>', 'filter by type (agent, team, model, tool)')
+        .action(async (options) => {
+        await listTargets(options);
+    });
+    return targets;
+}

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

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

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

@@ -0,0 +1,154 @@
+import { jest } from '@jest/globals';
+import { Command } from 'commander';
+// Mock execa to avoid real kubectl calls
+jest.unstable_mockModule('execa', () => ({
+    execa: jest.fn(),
+}));
+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 { execa } = await import('execa');
+const mockExeca = execa;
+const { createTargetsCommand } = await import('./index.js');
+describe('targets command', () => {
+    beforeEach(() => {
+        jest.clearAllMocks();
+    });
+    it('creates command with correct structure', () => {
+        const command = createTargetsCommand({});
+        expect(command).toBeInstanceOf(Command);
+        expect(command.name()).toBe('targets');
+    });
+    it('lists targets in text format', async () => {
+        // 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(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');
+    });
+    it('lists targets in json format', async () => {
+        // 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']);
+        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 () => {
+        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');
+    });
+    it('sorts targets by type then name', async () => {
+        // 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 - 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 () => {
+        // 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', 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:', 'kubectl not found');
+        expect(mockExit).toHaveBeenCalledWith(1);
+    });
+    it('list subcommand works', async () => {
+        // 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(mockExeca).toHaveBeenCalledWith('kubectl', ['get', 'models', '-o', 'json'], {
+            stdio: 'pipe',
+        });
+    });
+});

package/dist/commands/targets.d.ts

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

package/dist/commands/targets.js

@@ -0,0 +1,65 @@
+import { Command } from 'commander';
+import output from '../lib/output.js';
+import { ArkApiProxy } from '../lib/arkApiProxy.js';
+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);
+        }
+        // Sort targets by type and name
+        filteredTargets.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));
+        }
+        else {
+            if (filteredTargets.length === 0) {
+                output.warning('no targets available');
+                return;
+            }
+            // Simple list output with type/name format
+            for (const target of filteredTargets) {
+                console.log(target.id);
+            }
+        }
+    }
+    catch (error) {
+        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');
+    targets
+        .description('list available query targets (agents, teams, models, tools)')
+        .option('-o, --output <format>', 'output format (json or text)', 'text')
+        .option('-t, --type <type>', 'filter by type (agent, team, model, tool)')
+        .action(async (options) => {
+        await listTargets(options);
+    });
+    targets
+        .command('list')
+        .alias('ls')
+        .description('list all available query targets')
+        .option('-o, --output <format>', 'output format (json or text)', 'text')
+        .option('-t, --type <type>', 'filter by type (agent, team, model, tool)')
+        .action(async (options) => {
+        await listTargets(options);
+    });
+    return targets;
+}

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

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

package/dist/commands/teams/index.js

@@ -0,0 +1,64 @@
+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
+        const result = await execa('kubectl', ['get', 'teams', '-o', 'json'], {
+            stdio: 'pipe',
+        });
+        const data = JSON.parse(result.stdout);
+        const teams = data.items || [];
+        if (options.output === 'json') {
+            // Output the raw items for JSON format
+            console.log(JSON.stringify(teams, null, 2));
+        }
+        else {
+            if (teams.length === 0) {
+                output.info('No teams found');
+                return;
+            }
+            teams.forEach((team) => {
+                console.log(team.metadata.name);
+            });
+        }
+    }
+    catch (error) {
+        output.error('fetching teams:', error instanceof Error ? error.message : error);
+        process.exit(1);
+    }
+}
+export function createTeamsCommand(_) {
+    const teamsCommand = new Command('teams');
+    teamsCommand
+        .description('List available teams')
+        .option('-o, --output <format>', 'Output format (json)', 'text')
+        .action(async (options) => {
+        await listTeams(options);
+    });
+    const listCommand = new Command('list');
+    listCommand
+        .alias('ls')
+        .description('List available teams')
+        .option('-o, --output <format>', 'Output format (json)', 'text')
+        .action(async (options) => {
+        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/teams/index.spec.d.ts

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

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

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

package/dist/commands/teams/selector.d.ts

@@ -0,0 +1,8 @@
+import { Team, ArkApiClient } from '../../lib/arkApiClient.js';
+interface TeamSelectorProps {
+    arkApiClient: ArkApiClient;
+    onSelect: (team: Team) => void;
+    onExit: () => void;
+}
+export declare function TeamSelector({ arkApiClient, onSelect, onExit, }: TeamSelectorProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/commands/teams/selector.js

@@ -0,0 +1,55 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useState, useEffect } from 'react';
+import { Box, Text, useInput } from 'ink';
+export function TeamSelector({ arkApiClient, onSelect, onExit, }) {
+    const [selectedIndex, setSelectedIndex] = useState(0);
+    const [teams, setTeams] = useState([]);
+    const [loading, setLoading] = useState(true);
+    const [error, setError] = useState(null);
+    useEffect(() => {
+        arkApiClient
+            .getTeams()
+            .then((fetchedTeams) => {
+            setTeams(fetchedTeams);
+            setLoading(false);
+        })
+            .catch((err) => {
+            setError(err.message || 'Failed to fetch teams');
+            setLoading(false);
+        });
+    }, [arkApiClient]);
+    useInput((input, key) => {
+        if (key.escape) {
+            onExit();
+        }
+        else if (key.upArrow || input === 'k') {
+            setSelectedIndex((prev) => (prev === 0 ? teams.length - 1 : prev - 1));
+        }
+        else if (key.downArrow || input === 'j') {
+            setSelectedIndex((prev) => (prev === teams.length - 1 ? 0 : prev + 1));
+        }
+        else if (key.return) {
+            onSelect(teams[selectedIndex]);
+        }
+        else {
+            // Handle number keys for quick selection
+            const num = parseInt(input, 10);
+            if (!isNaN(num) && num >= 1 && num <= teams.length) {
+                onSelect(teams[num - 1]);
+            }
+        }
+    });
+    if (loading) {
+        return (_jsx(Box, { children: _jsx(Text, { children: "Loading teams..." }) }));
+    }
+    if (error) {
+        return (_jsx(Box, { children: _jsxs(Text, { color: "red", children: ["Error: ", error] }) }));
+    }
+    if (teams.length === 0) {
+        return (_jsx(Box, { children: _jsx(Text, { children: "No teams available" }) }));
+    }
+    const selectedTeam = teams[selectedIndex];
+    return (_jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: "gray", paddingX: 2, paddingY: 1, children: [_jsx(Box, { marginBottom: 1, children: _jsx(Text, { bold: true, children: "Select Team" }) }), _jsx(Box, { marginBottom: 1, children: _jsx(Text, { dimColor: true, children: "Choose a team to start a conversation with" }) }), _jsx(Box, { flexDirection: "column", children: teams.map((team, index) => (_jsx(Box, { marginBottom: 0, children: _jsxs(Text, { color: index === selectedIndex ? 'green' : undefined, children: [index === selectedIndex ? '❯ ' : '  ', index + 1, ". ", team.name, team.strategy ? ` (${team.strategy})` : ''] }) }, team.name))) }), selectedTeam &&
+                (selectedTeam.description || selectedTeam.members_count) && (_jsx(Box, { marginTop: 1, paddingLeft: 2, children: _jsx(Text, { dimColor: true, wrap: "wrap", children: selectedTeam.description ||
+                        `Members: ${selectedTeam.members_count}` }) })), _jsx(Box, { marginTop: 1, children: _jsx(Text, { dimColor: true, children: "Enter to confirm \u00B7 Number to select \u00B7 Esc to exit" }) })] }));
+}

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

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

package/dist/commands/tools/index.js

@@ -0,0 +1,49 @@
+import { Command } from 'commander';
+import { execa } from 'execa';
+import output from '../../lib/output.js';
+async function listTools(options) {
+    try {
+        // Use kubectl to get tools (MCPServers)
+        const result = await execa('kubectl', ['get', 'mcpservers', '-o', 'json'], {
+            stdio: 'pipe',
+        });
+        const data = JSON.parse(result.stdout);
+        const tools = data.items || [];
+        if (options.output === 'json') {
+            // Output the raw items for JSON format
+            console.log(JSON.stringify(tools, null, 2));
+        }
+        else {
+            if (tools.length === 0) {
+                output.info('No tools found');
+                return;
+            }
+            tools.forEach((tool) => {
+                console.log(tool.metadata.name);
+            });
+        }
+    }
+    catch (error) {
+        output.error('fetching tools:', error instanceof Error ? error.message : error);
+        process.exit(1);
+    }
+}
+export function createToolsCommand(_) {
+    const toolsCommand = new Command('tools');
+    toolsCommand
+        .description('List available tools')
+        .option('-o, --output <format>', 'Output format (json)', 'text')
+        .action(async (options) => {
+        await listTools(options);
+    });
+    const listCommand = new Command('list');
+    listCommand
+        .alias('ls')
+        .description('List available tools')
+        .option('-o, --output <format>', 'Output format (json)', 'text')
+        .action(async (options) => {
+        await listTools(options);
+    });
+    toolsCommand.addCommand(listCommand);
+    return toolsCommand;
+}

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

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

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

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

package/dist/commands/tools/selector.d.ts

@@ -0,0 +1,8 @@
+import { Tool, ArkApiClient } from '../../lib/arkApiClient.js';
+interface ToolSelectorProps {
+    arkApiClient: ArkApiClient;
+    onSelect: (tool: Tool) => void;
+    onExit: () => void;
+}
+export declare function ToolSelector({ arkApiClient, onSelect, onExit, }: ToolSelectorProps): import("react/jsx-runtime").JSX.Element;
+export {};