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

package/dist/lib/dev/tools/types.d.ts

@@ -1,50 +0,0 @@
-export interface ToolParameter {
-    name: string;
-    type?: string;
-}
-export interface DiscoveredTool {
-    name: string;
-    parameters: ToolParameter[];
-    return_type?: string;
-    docstring?: string;
-}
-export interface FileDiscoveryResult {
-    success: boolean;
-    file: string;
-    tools: DiscoveredTool[];
-    uses_fastmcp: boolean;
-    mcp_instance?: string;
-    server_name?: string;
-    error?: string;
-}
-export interface DirectoryDiscoveryResult {
-    directory: string;
-    files: FileDiscoveryResult[];
-    total_tools: number;
-    uses_fastmcp: boolean;
-}
-export type DiscoveryResult = FileDiscoveryResult | DirectoryDiscoveryResult;
-export interface ProjectDiscoveryResult {
-    path: string;
-    exists: boolean;
-    is_directory: boolean;
-    platform: 'python3' | null;
-    project_type: 'pyproject' | 'requirements' | null;
-    project_file: string | null;
-    project_name: string | null;
-    project_version: string | null;
-    has_fastmcp: boolean;
-    fastmcp_version: string | null;
-}
-export interface ProjectInfo {
-    path: string;
-    platform: 'python3';
-    projectType: 'pyproject' | 'requirements' | 'unknown';
-    hasVenv: boolean;
-    fastMCP: boolean;
-    fastMCPVersion?: string;
-}
-export interface ArkDevToolStatus extends ProjectInfo {
-    discovery?: DiscoveryResult;
-    tools: DiscoveredTool[];
-}

package/dist/lib/dev/tools/types.js

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

package/dist/lib/exec.d.ts

@@ -1 +0,0 @@
-export declare function fileExists(path: string): boolean;

package/dist/lib/exec.js

@@ -1,9 +0,0 @@
-import fs from 'fs';
-export function fileExists(path) {
-    try {
-        return fs.existsSync(path);
-    }
-    catch {
-        return false;
-    }
-}

package/dist/lib/gatewayManager.d.ts

@@ -1,24 +0,0 @@
-export declare class GatewayManager {
-    private kubernetesManager;
-    constructor();
-    /**
-     * Check if localhost-gateway port-forward is running by testing the endpoint
-     */
-    isPortForwardRunning(port?: number): Promise<boolean>;
-    /**
-     * Check if localhost-gateway service is deployed in cluster
-     */
-    isGatewayDeployed(): Promise<boolean>;
-    /**
-     * Check if port-forward is needed and provide setup instructions
-     */
-    checkPortForwardStatus(port?: number): Promise<{
-        isRunning: boolean;
-        needsSetup: boolean;
-        instructions?: string;
-    }>;
-    /**
-     * Get setup instructions for fresh installations
-     */
-    getSetupInstructions(): string;
-}

package/dist/lib/gatewayManager.js

@@ -1,85 +0,0 @@
-import * as k8s from '@kubernetes/client-node';
-import { KubernetesConfigManager } from './kubernetes.js';
-export class GatewayManager {
-    constructor() {
-        this.kubernetesManager = new KubernetesConfigManager();
-    }
-    /**
-     * Check if localhost-gateway port-forward is running by testing the endpoint
-     */
-    async isPortForwardRunning(port = 8080) {
-        try {
-            const axios = (await import('axios')).default;
-            await axios.get(`http://127.0.0.1:${port}`, {
-                timeout: 2000,
-                validateStatus: () => true,
-            });
-            return true;
-        }
-        catch {
-            return false;
-        }
-    }
-    /**
-     * Check if localhost-gateway service is deployed in cluster
-     */
-    async isGatewayDeployed() {
-        try {
-            await this.kubernetesManager.initializeConfig();
-            const kc = this.kubernetesManager.getKubeConfig();
-            const k8sApi = kc.makeApiClient(k8s.CoreV1Api);
-            await k8sApi.readNamespacedService({
-                name: 'localhost-gateway-nginx',
-                namespace: 'ark-system',
-            });
-            return true;
-        }
-        catch {
-            return false;
-        }
-    }
-    /**
-     * Check if port-forward is needed and provide setup instructions
-     */
-    async checkPortForwardStatus(port = 8080) {
-        const isRunning = await this.isPortForwardRunning(port);
-        if (isRunning) {
-            return { isRunning: true, needsSetup: false };
-        }
-        const isDeployed = await this.isGatewayDeployed();
-        if (!isDeployed) {
-            return {
-                isRunning: false,
-                needsSetup: true,
-                instructions: this.getSetupInstructions(),
-            };
-        }
-        return {
-            isRunning: false,
-            needsSetup: true,
-            instructions: `Gateway is deployed but port-forward not running. Start it with:\nkubectl port-forward -n ark-system service/localhost-gateway-nginx ${port}:80`,
-        };
-    }
-    /**
-     * Get setup instructions for fresh installations
-     */
-    getSetupInstructions() {
-        return `
-🔧 ARK Gateway Setup Required:
-
-To enable service discovery, you need to install the localhost-gateway:
-
-1. From your agents-at-scale project root, run:
-   make localhost-gateway-install
-
-2. This will:
-   - Install Gateway API CRDs
-   - Deploy NGINX Gateway Fabric
-   - Set up port-forwarding to localhost:8080
-
-3. Then run 'ark check status' again
-
-For more info: docs/content/ark-101/ark-gateway.mdx
-`;
-    }
-}

package/dist/lib/kubernetes.d.ts

@@ -1,28 +0,0 @@
-import * as k8s from '@kubernetes/client-node';
-import { KubernetesConfig } from './types.js';
-export declare class KubernetesConfigManager {
-    private kc;
-    constructor();
-    /**
-     * Get the KubeConfig instance for API client creation
-     */
-    getKubeConfig(): k8s.KubeConfig;
-    /**
-     * Initialize Kubernetes configuration similar to fark's approach
-     * Priority: in-cluster config > KUBECONFIG env > ~/.kube/config
-     */
-    initializeConfig(): Promise<KubernetesConfig>;
-    /**
-     * Get the API server URL for the current cluster
-     */
-    getClusterApiUrl(): string;
-    /**
-     * Detect ark-api service URL in the cluster
-     * This mimics how fark discovers services
-     */
-    getArkApiUrl(namespace?: string): Promise<string>;
-    /**
-     * Check if we can access the cluster
-     */
-    testClusterAccess(): Promise<boolean>;
-}

package/dist/lib/kubernetes.js

@@ -1,122 +0,0 @@
-import { promises as fs } from 'fs';
-import { homedir } from 'os';
-import { join } from 'path';
-import * as k8s from '@kubernetes/client-node';
-export class KubernetesConfigManager {
-    constructor() {
-        this.kc = new k8s.KubeConfig();
-    }
-    /**
-     * Get the KubeConfig instance for API client creation
-     */
-    getKubeConfig() {
-        return this.kc;
-    }
-    /**
-     * Initialize Kubernetes configuration similar to fark's approach
-     * Priority: in-cluster config > KUBECONFIG env > ~/.kube/config
-     */
-    async initializeConfig() {
-        let kubeconfig;
-        let currentContext;
-        let namespace;
-        let inCluster = false;
-        // Check if we're explicitly in a Kubernetes pod environment
-        const isInPod = process.env.KUBERNETES_SERVICE_HOST &&
-            process.env.KUBERNETES_SERVICE_PORT &&
-            process.env.POD_NAMESPACE;
-        if (isInPod) {
-            try {
-                // Try in-cluster config only if we're definitely in a pod
-                this.kc.loadFromCluster();
-                inCluster = true;
-                kubeconfig = '/var/run/secrets/kubernetes.io/serviceaccount';
-                namespace = process.env.POD_NAMESPACE || 'default';
-            }
-            catch (error) {
-                throw new Error(`Failed to load in-cluster Kubernetes configuration: ${error}`);
-            }
-        }
-        else {
-            // Use kubeconfig file for local development
-            try {
-                kubeconfig =
-                    process.env.KUBECONFIG || join(homedir(), '.kube', 'config');
-                // Check if kubeconfig file exists
-                await fs.access(kubeconfig);
-                this.kc.loadFromFile(kubeconfig);
-                // Get current context and namespace
-                currentContext = this.kc.currentContext;
-                // Simplified namespace detection - just use default for now
-                // Complex namespace detection can be added later if needed
-                namespace = 'default';
-            }
-            catch (error) {
-                throw new Error(`Failed to load Kubernetes configuration: ${error}`);
-            }
-        }
-        return {
-            kubeconfig,
-            currentContext,
-            namespace,
-            inCluster,
-        };
-    }
-    /**
-     * Get the API server URL for the current cluster
-     */
-    getClusterApiUrl() {
-        const cluster = this.kc.getCurrentCluster();
-        if (!cluster) {
-            throw new Error('No current cluster found in kubeconfig');
-        }
-        return cluster.server;
-    }
-    /**
-     * Detect ark-api service URL in the cluster
-     * This mimics how fark discovers services
-     */
-    async getArkApiUrl(namespace = 'default') {
-        const k8sApi = this.kc.makeApiClient(k8s.CoreV1Api);
-        try {
-            // Try to find ark-api service
-            const service = await k8sApi.readNamespacedService({
-                name: 'ark-api',
-                namespace,
-            });
-            if (service.spec?.type === 'LoadBalancer' &&
-                service.status?.loadBalancer?.ingress?.[0]) {
-                const ingress = service.status.loadBalancer.ingress[0];
-                const host = ingress.ip || ingress.hostname;
-                const port = service.spec.ports?.[0]?.port || 8080;
-                return `http://${host}:${port}`;
-            }
-            if (service.spec?.type === 'NodePort' && service.spec.ports?.[0]) {
-                const nodePort = service.spec.ports[0].nodePort;
-                const clusterUrl = this.getClusterApiUrl();
-                const clusterHost = new URL(clusterUrl).hostname;
-                return `http://${clusterHost}:${nodePort}`;
-            }
-            // Default to port-forward style access
-            const port = service.spec?.ports?.[0]?.port || 8080;
-            return `http://localhost:${port}`;
-        }
-        catch (error) {
-            // Service not found or not accessible
-            throw new Error(`ark-api service not found or not accessible in namespace '${namespace}': ${error instanceof Error ? error.message : error}`);
-        }
-    }
-    /**
-     * Check if we can access the cluster
-     */
-    async testClusterAccess() {
-        try {
-            const k8sApi = this.kc.makeApiClient(k8s.CoreV1Api);
-            await k8sApi.listNamespace();
-            return true;
-        }
-        catch {
-            return false;
-        }
-    }
-}

package/dist/lib/portUtils.d.ts

@@ -1,8 +0,0 @@
-/**
- * Check if a port is available
- */
-export declare function isPortAvailable(port: number): Promise<boolean>;
-/**
- * Find an available port, starting from the preferred port
- */
-export declare function findAvailablePort(preferredPort: number, maxAttempts?: number): Promise<number>;

package/dist/lib/portUtils.js

@@ -1,39 +0,0 @@
-import net from 'net';
-/**
- * Check if a port is available
- */
-export async function isPortAvailable(port) {
-    return new Promise((resolve) => {
-        const server = net.createServer();
-        server.once('error', (err) => {
-            if (err.code === 'EADDRINUSE') {
-                resolve(false);
-            }
-            else {
-                resolve(false);
-            }
-        });
-        server.once('listening', () => {
-            server.close();
-            resolve(true);
-        });
-        server.listen(port, '127.0.0.1');
-    });
-}
-/**
- * Find an available port, starting from the preferred port
- */
-export async function findAvailablePort(preferredPort, maxAttempts = 10) {
-    // First try the preferred port
-    if (await isPortAvailable(preferredPort)) {
-        return preferredPort;
-    }
-    // Try random ports
-    for (let i = 0; i < maxAttempts; i++) {
-        const randomPort = Math.floor(Math.random() * (65535 - 1024) + 1024);
-        if (await isPortAvailable(randomPort)) {
-            return randomPort;
-        }
-    }
-    throw new Error(`Could not find an available port after ${maxAttempts} attempts`);
-}

package/dist/lib/progress.d.ts

@@ -1,128 +0,0 @@
-/**
- * Progress indicators and user experience utilities for ARK CLI
- */
-export interface ProgressStep {
-    name: string;
-    status: 'pending' | 'running' | 'completed' | 'failed' | 'skipped';
-    message?: string;
-    duration?: number;
-}
-export declare class ProgressIndicator {
-    private title;
-    private steps;
-    private startTime;
-    constructor(title: string);
-    /**
-     * Add a step to the progress indicator
-     */
-    addStep(name: string, message?: string): void;
-    /**
-     * Start a step
-     */
-    startStep(name: string, message?: string): void;
-    /**
-     * Complete a step
-     */
-    completeStep(name: string, message?: string): void;
-    /**
-     * Fail a step
-     */
-    failStep(name: string, message?: string): void;
-    /**
-     * Skip a step
-     */
-    skipStep(name: string, message?: string): void;
-    /**
-     * Render the current progress
-     */
-    private renderProgress;
-    /**
-     * Complete the progress indicator
-     */
-    complete(message?: string): void;
-    /**
-     * Get status icon for a step
-     */
-    private getStatusIcon;
-    /**
-     * Get status color for a step
-     */
-    private getStatusColor;
-}
-/**
- * Simple spinner for long-running operations
- */
-export declare class Spinner {
-    private frames;
-    private index;
-    private interval;
-    private message;
-    constructor(message: string);
-    start(): void;
-    stop(finalMessage?: string): void;
-    fail(errorMessage?: string): void;
-}
-/**
- * Enhanced prompts with better validation and user guidance
- */
-export declare class EnhancedPrompts {
-    /**
-     * Show a helpful tip to the user
-     */
-    static showTip(message: string): void;
-    /**
-     * Show a warning to the user
-     */
-    static showWarning(message: string): void;
-    /**
-     * Show information to the user
-     */
-    static showInfo(message: string): void;
-    /**
-     * Show a success message
-     */
-    static showSuccess(message: string): void;
-    /**
-     * Show available options for a choice
-     */
-    static showChoiceHelp(title: string, choices: Array<{
-        name: string;
-        description: string;
-    }>): void;
-    /**
-     * Show next steps after completion
-     */
-    static showNextSteps(title: string, steps: string[]): void;
-    /**
-     * Show a separator for better visual organization
-     */
-    static showSeparator(title?: string): void;
-}
-/**
- * Utility for consistent formatting of output
- */
-export declare class OutputFormatter {
-    /**
-     * Format a list of key-value pairs
-     */
-    static formatKeyValueList(items: Array<{
-        key: string;
-        value: string;
-        highlight?: boolean;
-    }>): void;
-    /**
-     * Format a file list with icons
-     */
-    static formatFileList(files: Array<{
-        path: string;
-        type: 'file' | 'directory';
-        description?: string;
-    }>): void;
-    /**
-     * Format command examples
-     */
-    static formatCommands(title: string, commands: Array<{
-        command: string;
-        description: string;
-    }>): void;
-}