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

package/dist/index.js

@@ -6,15 +6,18 @@ import { createRequire } from 'module';
 const require = createRequire(import.meta.url);
 const packageJson = require('../package.json');
 import output from './lib/output.js';
+import { startup } from './lib/startup.js';
 import { createAgentsCommand } from './commands/agents/index.js';
 import { createChatCommand } from './commands/chat/index.js';
 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';
+import { createQueryCommand } from './commands/query/index.js';
 import { createUninstallCommand } from './commands/uninstall/index.js';
 import { createStatusCommand } from './commands/status/index.js';
 import { createConfigCommand } from './commands/config/index.js';
@@ -23,35 +26,39 @@ import { createTeamsCommand } from './commands/teams/index.js';
 import { createToolsCommand } from './commands/tools/index.js';
 import { createRoutesCommand } from './commands/routes/index.js';
 import MainMenu from './ui/MainMenu.js';
-function showMainMenu() {
-    const app = render(_jsx(MainMenu, {}));
+function showMainMenu(config) {
+    const app = render(_jsx(MainMenu, { config: config }));
     globalThis.inkApp = app;
 }
 async function main() {
+    // Initialize CLI - check requirements and load config
+    const config = await startup();
     const program = new Command();
     program
         .name(packageJson.name)
         .description(packageJson.description)
         .version(packageJson.version);
-    program.addCommand(createAgentsCommand());
-    program.addCommand(createChatCommand());
-    program.addCommand(createClusterCommand());
-    program.addCommand(createCompletionCommand());
-    program.addCommand(createDashboardCommand());
-    program.addCommand(createDevCommand());
-    program.addCommand(createGenerateCommand());
-    program.addCommand(createInstallCommand());
-    program.addCommand(createModelsCommand());
-    program.addCommand(createUninstallCommand());
-    program.addCommand(createStatusCommand());
-    program.addCommand(createConfigCommand());
-    program.addCommand(createTargetsCommand());
-    program.addCommand(createTeamsCommand());
-    program.addCommand(createToolsCommand());
-    program.addCommand(createRoutesCommand());
+    program.addCommand(createAgentsCommand(config));
+    program.addCommand(createChatCommand(config));
+    program.addCommand(createClusterCommand(config));
+    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(createConfigCommand(config));
+    program.addCommand(createTargetsCommand(config));
+    program.addCommand(createTeamsCommand(config));
+    program.addCommand(createToolsCommand(config));
+    program.addCommand(createRoutesCommand(config));
     // If no args provided, show interactive menu
     if (process.argv.length === 2) {
-        showMainMenu();
+        showMainMenu(config);
         return;
     }
     await program.parseAsync(process.argv);

package/dist/lib/arkServiceProxy.js

@@ -18,9 +18,11 @@ export class ArkServiceProxy {
                 'port-forward',
                 `service/${this.service.k8sServiceName}`,
                 `${this.localPort}:${this.service.k8sServicePort}`,
-                '--namespace',
-                this.service.namespace,
             ];
+            // Add namespace flag only if namespace is defined
+            if (this.service.namespace) {
+                args.push('--namespace', this.service.namespace);
+            }
             this.kubectlProcess = spawn('kubectl', args, {
                 stdio: ['ignore', 'pipe', 'pipe'],
             });

package/dist/lib/arkStatus.d.ts

@@ -1,3 +1,8 @@
+/**
+ * Get current installed ARK version
+ * @returns version string if found, undefined otherwise
+ */
+export declare function getArkVersion(): Promise<string | undefined>;
 /**
  * Check if ARK is ready by verifying the ark-controller is running
  * @returns true if ark-controller deployment exists and has ready replicas

package/dist/lib/arkStatus.js

@@ -1,4 +1,21 @@
 import { execa } from 'execa';
+import { arkServices } from '../arkServices.js';
+/**
+ * Get current installed ARK version
+ * @returns version string if found, undefined otherwise
+ */
+export async function getArkVersion() {
+    try {
+        const controller = arkServices['ark-controller'];
+        const { stdout } = await execa('helm', ['list', '-n', controller.namespace, '-o', 'json'], { stdio: 'pipe' });
+        const releases = JSON.parse(stdout);
+        const arkController = releases.find((r) => r.name === controller.helmReleaseName);
+        return arkController?.app_version;
+    }
+    catch {
+        return undefined;
+    }
+}
 /**
  * Check if ARK is ready by verifying the ark-controller is running
  * @returns true if ark-controller deployment exists and has ready replicas
@@ -10,11 +27,53 @@ export async function isArkReady() {
         const deployment = JSON.parse(result.stdout);
         const readyReplicas = deployment.status?.readyReplicas || 0;
         const replicas = deployment.spec?.replicas || 0;
+        // If main deployment has 0 replicas, check devspace deployment
+        if (replicas === 0) {
+            try {
+                const devResult = await execa('kubectl', [
+                    'get',
+                    'deployment',
+                    'ark-controller-devspace',
+                    '-n',
+                    'ark-system',
+                    '-o',
+                    'json',
+                ], { stdio: 'pipe' });
+                const devDeployment = JSON.parse(devResult.stdout);
+                const devReadyReplicas = devDeployment.status?.readyReplicas || 0;
+                const devReplicas = devDeployment.spec?.replicas || 0;
+                // ARK is ready if devspace deployment has ready replicas
+                return devReadyReplicas > 0 && devReadyReplicas === devReplicas;
+            }
+            catch {
+                // Devspace deployment doesn't exist
+                return false;
+            }
+        }
         // ARK is ready if deployment exists and has at least one ready replica
         return readyReplicas > 0 && readyReplicas === replicas;
     }
     catch {
-        // Deployment doesn't exist or kubectl failed
-        return false;
+        // Main deployment doesn't exist, try devspace deployment
+        try {
+            const devResult = await execa('kubectl', [
+                'get',
+                'deployment',
+                'ark-controller-devspace',
+                '-n',
+                'ark-system',
+                '-o',
+                'json',
+            ], { stdio: 'pipe' });
+            const devDeployment = JSON.parse(devResult.stdout);
+            const devReadyReplicas = devDeployment.status?.readyReplicas || 0;
+            const devReplicas = devDeployment.spec?.replicas || 0;
+            // ARK is ready if devspace deployment has ready replicas
+            return devReadyReplicas > 0 && devReadyReplicas === devReplicas;
+        }
+        catch {
+            // Neither deployment exists or kubectl failed
+            return false;
+        }
     }
 }

package/dist/lib/arkStatus.spec.d.ts

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

package/dist/lib/arkStatus.spec.js

@@ -0,0 +1,49 @@
+import { describe, it, expect, jest, beforeEach } from '@jest/globals';
+// Mock execa using unstable_mockModule
+jest.unstable_mockModule('execa', () => ({
+    execa: jest.fn(),
+}));
+// Dynamic imports after mock
+const { execa } = await import('execa');
+const { isArkReady } = await import('./arkStatus.js');
+describe('arkStatus with __mocks__', () => {
+    describe('isArkReady', () => {
+        beforeEach(() => {
+            jest.clearAllMocks();
+        });
+        it('should return true when ark-controller is deployed and ready', async () => {
+            // Mock successful kubectl response with ready deployment
+            const mockDeployment = {
+                metadata: { name: 'ark-controller' },
+                spec: { replicas: 3 },
+                status: {
+                    readyReplicas: 3,
+                    availableReplicas: 3,
+                },
+            };
+            execa.mockResolvedValue({
+                stdout: JSON.stringify(mockDeployment),
+                stderr: '',
+                exitCode: 0,
+                failed: false,
+            });
+            const result = await isArkReady();
+            expect(result).toBe(true);
+            expect(execa).toHaveBeenCalledWith('kubectl', [
+                'get',
+                'deployment',
+                'ark-controller',
+                '-n',
+                'ark-system',
+                '-o',
+                'json',
+            ], { stdio: 'pipe' });
+        });
+        it('should return false when kubectl fails', async () => {
+            // Mock kubectl failure
+            execa.mockRejectedValue(new Error('kubectl not found'));
+            const result = await isArkReady();
+            expect(result).toBe(false);
+        });
+    });
+});

package/dist/lib/chatClient.js

@@ -1,4 +1,3 @@
-import output from './output.js';
 export class ChatClient {
     constructor(arkApiClient) {
         this.arkApiClient = arkApiClient;
@@ -93,8 +92,7 @@ export class ChatClient {
             }
         }
         catch (error) {
-            const errorMessage = error instanceof Error ? error.message : String(error);
-            output.error('failed to call openai api:', errorMessage);
+            // Don't log here - error will be displayed in the message thread
             throw error;
         }
     }

package/dist/lib/cluster.js

@@ -1,10 +1,7 @@
-import { executeCommand } from './exec.js';
+import { execa } from 'execa';
 export async function detectClusterType() {
     try {
-        const { stdout } = await executeCommand('kubectl', [
-            'config',
-            'current-context',
-        ]);
+        const { stdout } = await execa('kubectl', ['config', 'current-context']);
         const context = stdout.trim();
         if (context.includes('minikube')) {
             return { type: 'minikube', context };
@@ -39,7 +36,7 @@ export async function getClusterInfo(context) {
         // If context is provided, use it
         const contextArgs = context ? ['--context', context] : [];
         // Get all config info in one command
-        const { stdout: configJson } = await executeCommand('kubectl', [
+        const { stdout: configJson } = await execa('kubectl', [
             'config',
             'view',
             '--minify',
@@ -62,12 +59,12 @@ export async function getClusterInfo(context) {
         switch (clusterInfo.type) {
             case 'minikube':
                 try {
-                    const { stdout } = await executeCommand('minikube', ['ip']);
+                    const { stdout } = await execa('minikube', ['ip']);
                     ip = stdout.trim();
                 }
                 catch {
                     // Fallback to kubectl if minikube command fails
-                    const { stdout } = await executeCommand('kubectl', [
+                    const { stdout } = await execa('kubectl', [
                         'get',
                         'nodes',
                         '-o',
@@ -77,7 +74,7 @@ export async function getClusterInfo(context) {
                 }
                 break;
             case 'kind': {
-                const { stdout: kindOutput } = await executeCommand('kubectl', [
+                const { stdout: kindOutput } = await execa('kubectl', [
                     'get',
                     'nodes',
                     '-o',
@@ -90,7 +87,7 @@ export async function getClusterInfo(context) {
                 ip = 'localhost';
                 break;
             case 'k3s': {
-                const { stdout: k3sOutput } = await executeCommand('kubectl', [
+                const { stdout: k3sOutput } = await execa('kubectl', [
                     'get',
                     'nodes',
                     '-o',
@@ -102,7 +99,7 @@ export async function getClusterInfo(context) {
             case 'cloud':
                 // For cloud clusters, try to get the external IP or load balancer IP
                 try {
-                    const { stdout: lbOutput } = await executeCommand('kubectl', [
+                    const { stdout: lbOutput } = await execa('kubectl', [
                         'get',
                         'svc',
                         '-n',
@@ -113,7 +110,7 @@ export async function getClusterInfo(context) {
                     ]);
                     ip = lbOutput.trim();
                     if (!ip) {
-                        const { stdout: hostnameOutput } = await executeCommand('kubectl', [
+                        const { stdout: hostnameOutput } = await execa('kubectl', [
                             'get',
                             'svc',
                             '-n',
@@ -127,7 +124,7 @@ export async function getClusterInfo(context) {
                 }
                 catch {
                     // Fallback to node IP
-                    const { stdout: nodeOutput } = await executeCommand('kubectl', [
+                    const { stdout: nodeOutput } = await execa('kubectl', [
                         'get',
                         'nodes',
                         '-o',
@@ -137,7 +134,7 @@ export async function getClusterInfo(context) {
                 }
                 break;
             default: {
-                const { stdout: defaultOutput } = await executeCommand('kubectl', [
+                const { stdout: defaultOutput } = await execa('kubectl', [
                     'get',
                     'nodes',
                     '-o',

package/dist/lib/cluster.spec.d.ts

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