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

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'));

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 {};

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

@@ -0,0 +1,78 @@
+import { jest } from '@jest/globals';
+import { Command } from 'commander';
+const mockLoadConfig = jest.fn();
+const mockGetConfigPaths = jest.fn();
+const mockFormatConfig = jest.fn();
+jest.unstable_mockModule('../../lib/config.js', () => ({
+    loadConfig: mockLoadConfig,
+    getConfigPaths: mockGetConfigPaths,
+    formatConfig: mockFormatConfig,
+}));
+const mockExistsSync = jest.fn();
+jest.unstable_mockModule('fs', () => ({
+    default: {
+        existsSync: mockExistsSync,
+    },
+    existsSync: mockExistsSync,
+}));
+const mockConsoleLog = jest.spyOn(console, 'log').mockImplementation(() => { });
+const { createConfigCommand } = await import('./index.js');
+describe('config command', () => {
+    beforeEach(() => {
+        jest.clearAllMocks();
+        // Reset environment variables
+        delete process.env.ARK_CHAT_STREAMING;
+        delete process.env.ARK_CHAT_OUTPUT_FORMAT;
+    });
+    it('creates command with correct structure', () => {
+        const command = createConfigCommand({});
+        expect(command).toBeInstanceOf(Command);
+        expect(command.name()).toBe('config');
+    });
+    it('displays config paths and environment variables', async () => {
+        const mockConfig = { defaultModel: 'test-model' };
+        const mockPaths = {
+            user: '/home/user/.arkrc.yaml',
+            project: '/project/.arkrc.yaml',
+        };
+        mockLoadConfig.mockReturnValue(mockConfig);
+        mockGetConfigPaths.mockReturnValue(mockPaths);
+        mockFormatConfig.mockReturnValue('formatted config');
+        mockExistsSync.mockReturnValue(true);
+        const command = createConfigCommand({});
+        await command.parseAsync(['node', 'test']);
+        expect(mockLoadConfig).toHaveBeenCalled();
+        expect(mockGetConfigPaths).toHaveBeenCalled();
+        expect(mockFormatConfig).toHaveBeenCalledWith(mockConfig);
+        expect(mockExistsSync).toHaveBeenCalledWith(mockPaths.user);
+        expect(mockExistsSync).toHaveBeenCalledWith(mockPaths.project);
+    });
+    it('shows when config files do not exist', async () => {
+        const mockPaths = {
+            user: '/home/user/.arkrc.yaml',
+            project: '/project/.arkrc.yaml',
+        };
+        mockLoadConfig.mockReturnValue({});
+        mockGetConfigPaths.mockReturnValue(mockPaths);
+        mockFormatConfig.mockReturnValue('');
+        mockExistsSync.mockReturnValue(false);
+        const command = createConfigCommand({});
+        await command.parseAsync(['node', 'test']);
+        expect(mockExistsSync).toHaveBeenCalledWith(mockPaths.user);
+        expect(mockExistsSync).toHaveBeenCalledWith(mockPaths.project);
+        // Should show that files don't exist
+        expect(mockConsoleLog).toHaveBeenCalled();
+    });
+    it('displays environment variables when set', async () => {
+        process.env.ARK_CHAT_STREAMING = 'true';
+        process.env.ARK_CHAT_OUTPUT_FORMAT = 'json';
+        mockLoadConfig.mockReturnValue({});
+        mockGetConfigPaths.mockReturnValue({ user: '', project: '' });
+        mockFormatConfig.mockReturnValue('');
+        mockExistsSync.mockReturnValue(false);
+        const command = createConfigCommand({});
+        await command.parseAsync(['node', 'test']);
+        // Should display the environment variables
+        expect(mockConsoleLog).toHaveBeenCalled();
+    });
+});

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

@@ -1,3 +1,4 @@
 import { Command } from 'commander';
+import type { ArkConfig } from '../../lib/config.js';
 export declare function openDashboard(): Promise<void>;
-export declare function createDashboardCommand(): Command;
+export declare function createDashboardCommand(_: ArkConfig): Command;

package/dist/commands/dashboard/index.js

@@ -30,7 +30,7 @@ export async function openDashboard() {
         process.exit(1);
     }
 }
-export function createDashboardCommand() {
+export function createDashboardCommand(_) {
     const dashboardCommand = new Command('dashboard');
     dashboardCommand
         .description('Open the ARK dashboard in your browser')

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

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

package/dist/commands/dev/index.js

@@ -1,6 +1,6 @@
 import { Command } from 'commander';
 import { createToolCommand } from './tool/index.js';
-export function createDevCommand() {
+export function createDevCommand(_) {
     const devCommand = new Command('dev');
     devCommand.description('Development tools for ARK');
     // Add subcommands