@agents-at-scale/ark 0.1.35 → 0.1.36

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/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/uninstall/index.d.ts

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

package/dist/commands/uninstall/index.js

@@ -0,0 +1,101 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import { execute } from '../../lib/commands.js';
+import inquirer from 'inquirer';
+import { showNoClusterError } from '../../lib/startup.js';
+import output from '../../lib/output.js';
+import { getInstallableServices } from '../../arkServices.js';
+async function uninstallService(service, verbose = false) {
+    const helmArgs = ['uninstall', service.helmReleaseName, '--ignore-not-found'];
+    // Only add namespace flag if service has explicit namespace
+    if (service.namespace) {
+        helmArgs.push('--namespace', service.namespace);
+    }
+    await execute('helm', helmArgs, { stdio: 'inherit' }, { verbose });
+}
+async function uninstallArk(config, serviceName, options = {}) {
+    // Check cluster connectivity from config
+    if (!config.clusterInfo) {
+        showNoClusterError();
+        process.exit(1);
+    }
+    const clusterInfo = config.clusterInfo;
+    // Show cluster info
+    output.success(`connected to cluster: ${chalk.bold(clusterInfo.context)}`);
+    console.log(); // Add blank line after cluster info
+    // If a specific service is requested, uninstall only that service
+    if (serviceName) {
+        const services = getInstallableServices();
+        const service = Object.values(services).find((s) => s.name === serviceName);
+        if (!service) {
+            output.error(`service '${serviceName}' not found`);
+            output.info('available services:');
+            for (const s of Object.values(services)) {
+                output.info(`  ${s.name}`);
+            }
+            process.exit(1);
+        }
+        output.info(`uninstalling ${service.name}...`);
+        try {
+            await uninstallService(service, options.verbose);
+            output.success(`${service.name} uninstalled successfully`);
+        }
+        catch (error) {
+            output.error(`failed to uninstall ${service.name}`);
+            console.error(error);
+            process.exit(1);
+        }
+        return;
+    }
+    // Get installable services and iterate through them in reverse order for clean uninstall
+    const services = getInstallableServices();
+    const serviceEntries = Object.entries(services).reverse();
+    for (const [, service] of serviceEntries) {
+        let shouldUninstall = false;
+        try {
+            // Ask for confirmation
+            shouldUninstall =
+                options.yes ||
+                    (await inquirer.prompt([
+                        {
+                            type: 'confirm',
+                            name: 'shouldUninstall',
+                            message: `uninstall ${chalk.bold(service.name)}? ${service.description ? chalk.gray(`(${service.description.toLowerCase()})`) : ''}`,
+                            default: true,
+                        },
+                    ])).shouldUninstall;
+        }
+        catch (error) {
+            // Handle Ctrl-C gracefully
+            if (error && error.name === 'ExitPromptError') {
+                console.log('\nUninstallation cancelled');
+                process.exit(130); // Standard exit code for SIGINT
+            }
+            throw error;
+        }
+        if (!shouldUninstall) {
+            output.warning(`skipping ${service.name}`);
+            continue;
+        }
+        try {
+            await uninstallService(service, options.verbose);
+            console.log(); // Add blank line after command output
+        }
+        catch {
+            // Continue with remaining charts on error
+            console.log(); // Add blank line after error output
+        }
+    }
+}
+export function createUninstallCommand(config) {
+    const command = new Command('uninstall');
+    command
+        .description('Uninstall ARK components using Helm')
+        .argument('[service]', 'specific service to uninstall, or all if omitted')
+        .option('-y, --yes', 'automatically confirm all uninstallations')
+        .option('-v, --verbose', 'show commands being executed')
+        .action(async (service, options) => {
+        await uninstallArk(config, service, options);
+    });
+    return command;
+}

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

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

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

@@ -0,0 +1,125 @@
+import { jest } from '@jest/globals';
+import { Command } from 'commander';
+const mockExeca = jest.fn(() => Promise.resolve());
+jest.unstable_mockModule('execa', () => ({
+    execa: mockExeca,
+}));
+const mockGetClusterInfo = jest.fn();
+jest.unstable_mockModule('../../lib/cluster.js', () => ({
+    getClusterInfo: mockGetClusterInfo,
+}));
+const mockGetInstallableServices = jest.fn();
+const mockArkServices = {};
+jest.unstable_mockModule('../../arkServices.js', () => ({
+    getInstallableServices: mockGetInstallableServices,
+    arkServices: mockArkServices,
+}));
+const mockOutput = {
+    error: jest.fn(),
+    info: jest.fn(),
+    success: jest.fn(),
+    warning: jest.fn(),
+};
+jest.unstable_mockModule('../../lib/output.js', () => ({
+    default: mockOutput,
+}));
+const mockExit = jest.spyOn(process, 'exit').mockImplementation((() => {
+    throw new Error('process.exit called');
+}));
+jest.spyOn(console, 'log').mockImplementation(() => { });
+jest.spyOn(console, 'error').mockImplementation(() => { });
+const { createUninstallCommand } = await import('./index.js');
+describe('uninstall command', () => {
+    const mockConfig = {
+        clusterInfo: {
+            context: 'test-cluster',
+            type: 'minikube',
+            namespace: 'default',
+        },
+    };
+    beforeEach(() => {
+        jest.clearAllMocks();
+        mockGetClusterInfo.mockResolvedValue({
+            context: 'test-cluster',
+            type: 'minikube',
+            namespace: 'default',
+        });
+    });
+    it('creates command with correct structure', () => {
+        const command = createUninstallCommand(mockConfig);
+        expect(command).toBeInstanceOf(Command);
+        expect(command.name()).toBe('uninstall');
+    });
+    it('uninstalls single service with correct helm parameters', async () => {
+        const mockService = {
+            name: 'ark-api',
+            helmReleaseName: 'ark-api',
+            namespace: 'ark-system',
+        };
+        mockGetInstallableServices.mockReturnValue({
+            'ark-api': mockService,
+        });
+        const command = createUninstallCommand(mockConfig);
+        await command.parseAsync(['node', 'test', 'ark-api']);
+        expect(mockExeca).toHaveBeenCalledWith('helm', [
+            'uninstall',
+            'ark-api',
+            '--ignore-not-found',
+            '--namespace',
+            'ark-system',
+        ], {
+            stdio: 'inherit',
+        });
+        expect(mockOutput.success).toHaveBeenCalledWith('ark-api uninstalled successfully');
+    });
+    it('shows error when service not found', async () => {
+        mockGetInstallableServices.mockReturnValue({
+            'ark-api': { name: 'ark-api' },
+            'ark-controller': { name: 'ark-controller' },
+        });
+        const command = createUninstallCommand(mockConfig);
+        await expect(command.parseAsync(['node', 'test', 'invalid-service'])).rejects.toThrow('process.exit called');
+        expect(mockOutput.error).toHaveBeenCalledWith("service 'invalid-service' not found");
+        expect(mockOutput.info).toHaveBeenCalledWith('available services:');
+        expect(mockOutput.info).toHaveBeenCalledWith('  ark-api');
+        expect(mockOutput.info).toHaveBeenCalledWith('  ark-controller');
+        expect(mockExit).toHaveBeenCalledWith(1);
+    });
+    it('handles service without namespace (uses current context)', async () => {
+        const mockService = {
+            name: 'ark-dashboard',
+            helmReleaseName: 'ark-dashboard',
+            // namespace is undefined - should use current context
+        };
+        mockGetInstallableServices.mockReturnValue({
+            'ark-dashboard': mockService,
+        });
+        const command = createUninstallCommand(mockConfig);
+        await command.parseAsync(['node', 'test', 'ark-dashboard']);
+        // Should NOT include --namespace flag
+        expect(mockExeca).toHaveBeenCalledWith('helm', ['uninstall', 'ark-dashboard', '--ignore-not-found'], {
+            stdio: 'inherit',
+        });
+    });
+    it('handles helm uninstall error gracefully', async () => {
+        const mockService = {
+            name: 'ark-api',
+            helmReleaseName: 'ark-api',
+            namespace: 'ark-system',
+        };
+        mockGetInstallableServices.mockReturnValue({
+            'ark-api': mockService,
+        });
+        mockExeca.mockRejectedValue(new Error('helm failed'));
+        const command = createUninstallCommand(mockConfig);
+        await expect(command.parseAsync(['node', 'test', 'ark-api'])).rejects.toThrow('process.exit called');
+        expect(mockOutput.error).toHaveBeenCalledWith('failed to uninstall ark-api');
+        expect(mockExit).toHaveBeenCalledWith(1);
+    });
+    it('exits when cluster not connected', async () => {
+        mockGetClusterInfo.mockResolvedValue({ error: true });
+        const command = createUninstallCommand({});
+        await expect(command.parseAsync(['node', 'test', 'ark-api'])).rejects.toThrow('process.exit called');
+        expect(mockExit).toHaveBeenCalledWith(1);
+    });
+});

package/dist/components/ChatUI.d.ts

@@ -0,0 +1,16 @@
+import * as React from 'react';
+import { ArkApiClient } from '../lib/arkApiClient.js';
+import { ArkApiProxy } from '../lib/arkApiProxy.js';
+interface ChatUIProps {
+    initialTargetId?: string;
+    arkApiClient: ArkApiClient;
+    arkApiProxy: ArkApiProxy;
+    config?: {
+        chat?: {
+            streaming?: boolean;
+            outputFormat?: 'text' | 'markdown';
+        };
+    };
+}
+declare const ChatUI: React.FC<ChatUIProps>;
+export default ChatUI;