@agents-at-scale/ark 0.1.40 → 0.1.42

package/dist/components/ChatUI.js

@@ -7,10 +7,7 @@ import { marked } from 'marked';
 // @ts-ignore - no types available
 import TerminalRenderer from 'marked-terminal';
 import { APIError } from 'openai';
-import { AgentSelector } from '../ui/AgentSelector.js';
-import { ModelSelector } from '../ui/ModelSelector.js';
-import { TeamSelector } from '../ui/TeamSelector.js';
-import { ToolSelector } from '../ui/ToolSelector.js';
+import { TargetSelector } from '../ui/TargetSelector.js';
 import { useAsyncOperation, AsyncOperationStatus } from './AsyncOperation.js';
 import { createConnectingToArkOperation } from '../ui/asyncOperations/connectingToArk.js';
 // Generate a unique ID for messages
@@ -21,10 +18,12 @@ const generateMessageId = () => {
 // Configure marked with terminal renderer for markdown output
 const configureMarkdown = () => {
     marked.setOptions({
+        // @ts-expect-error - TerminalRenderer types are incomplete
         renderer: new TerminalRenderer({
             showSectionPrefix: false,
             width: 80,
             reflowText: true,
+            // @ts-expect-error - preserveNewlines exists but not in types
             preserveNewlines: true,
         }),
     });
@@ -48,6 +47,12 @@ const ChatUI = ({ initialTargetId, arkApiClient, arkApiProxy, config, }) => {
     const [showModelSelector, setShowModelSelector] = React.useState(false);
     const [showTeamSelector, setShowTeamSelector] = React.useState(false);
     const [showToolSelector, setShowToolSelector] = React.useState(false);
+    const [agents, setAgents] = React.useState([]);
+    const [models, setModels] = React.useState([]);
+    const [teams, setTeams] = React.useState([]);
+    const [tools, setTools] = React.useState([]);
+    const [selectorLoading, setSelectorLoading] = React.useState(false);
+    const [selectorError, setSelectorError] = React.useState(undefined);
     // Message history navigation
     const [messageHistory, setMessageHistory] = React.useState([]);
     const [historyIndex, setHistoryIndex] = React.useState(-1);
@@ -56,6 +61,50 @@ const ChatUI = ({ initialTargetId, arkApiClient, arkApiProxy, config, }) => {
         streamingEnabled: config?.chat?.streaming ?? true,
         currentTarget: undefined,
     });
+    React.useEffect(() => {
+        if (showAgentSelector && agents.length === 0) {
+            setSelectorLoading(true);
+            setSelectorError(undefined);
+            arkApiClient
+                .getAgents()
+                .then(setAgents)
+                .catch((err) => setSelectorError(err.message))
+                .finally(() => setSelectorLoading(false));
+        }
+    }, [showAgentSelector, arkApiClient, agents.length]);
+    React.useEffect(() => {
+        if (showModelSelector && models.length === 0) {
+            setSelectorLoading(true);
+            setSelectorError(undefined);
+            arkApiClient
+                .getModels()
+                .then(setModels)
+                .catch((err) => setSelectorError(err.message))
+                .finally(() => setSelectorLoading(false));
+        }
+    }, [showModelSelector, arkApiClient, models.length]);
+    React.useEffect(() => {
+        if (showTeamSelector && teams.length === 0) {
+            setSelectorLoading(true);
+            setSelectorError(undefined);
+            arkApiClient
+                .getTeams()
+                .then(setTeams)
+                .catch((err) => setSelectorError(err.message))
+                .finally(() => setSelectorLoading(false));
+        }
+    }, [showTeamSelector, arkApiClient, teams.length]);
+    React.useEffect(() => {
+        if (showToolSelector && tools.length === 0) {
+            setSelectorLoading(true);
+            setSelectorError(undefined);
+            arkApiClient
+                .getTools()
+                .then(setTools)
+                .catch((err) => setSelectorError(err.message))
+                .finally(() => setSelectorLoading(false));
+        }
+    }, [showToolSelector, arkApiClient, tools.length]);
     const chatClientRef = React.useRef(undefined);
     // Configure markdown when output format changes
     React.useEffect(() => {
@@ -608,8 +657,10 @@ const ChatUI = ({ initialTargetId, arkApiClient, arkApiProxy, config, }) => {
     }
     // Show agent selector if requested
     if (showAgentSelector) {
-        return (_jsx(AgentSelector, { arkApiClient: arkApiClient, onSelect: (agent) => {
-                // Update the target to the selected agent
+        return (_jsx(TargetSelector, { targets: agents, title: "Select Agent", subtitle: "Choose an agent to start a conversation with", loading: selectorLoading, error: selectorError, formatInlineDetail: (t) => t.description, showDetailPanel: true, onSelect: (target) => {
+                const agent = agents.find((a) => a.name === target.name);
+                if (!agent)
+                    return;
                 const agentTarget = {
                     id: `agent/${agent.name}`,
                     name: agent.name,
@@ -620,7 +671,6 @@ const ChatUI = ({ initialTargetId, arkApiClient, arkApiProxy, config, }) => {
                 setChatConfig((prev) => ({ ...prev, currentTarget: agentTarget }));
                 setMessages([]);
                 setShowAgentSelector(false);
-                // Add system message about the selection
                 const systemMessage = {
                     id: generateMessageId(),
                     type: 'system',
@@ -633,8 +683,18 @@ const ChatUI = ({ initialTargetId, arkApiClient, arkApiProxy, config, }) => {
     }
     // Show model selector if requested
     if (showModelSelector) {
-        return (_jsx(ModelSelector, { arkApiClient: arkApiClient, onSelect: (model) => {
-                // Update the target to the selected model
+        return (_jsx(TargetSelector, { targets: models, title: "Select Model", subtitle: "Choose a model to start a conversation with", loading: selectorLoading, error: selectorError, formatLabel: (t) => {
+                const model = models.find((m) => m.name === t.name);
+                return model
+                    ? `${model.name}${model.type ? ` (${model.type})` : ''}`
+                    : t.name;
+            }, formatInlineDetail: (t) => {
+                const model = models.find((m) => m.name === t.name);
+                return model?.model;
+            }, showDetailPanel: false, onSelect: (target) => {
+                const model = models.find((m) => m.name === target.name);
+                if (!model)
+                    return;
                 const modelTarget = {
                     id: `model/${model.name}`,
                     name: model.name,
@@ -645,7 +705,6 @@ const ChatUI = ({ initialTargetId, arkApiClient, arkApiProxy, config, }) => {
                 setChatConfig((prev) => ({ ...prev, currentTarget: modelTarget }));
                 setMessages([]);
                 setShowModelSelector(false);
-                // Add system message about the selection
                 const systemMessage = {
                     id: generateMessageId(),
                     type: 'system',
@@ -658,8 +717,15 @@ const ChatUI = ({ initialTargetId, arkApiClient, arkApiProxy, config, }) => {
     }
     // Show team selector if requested
     if (showTeamSelector) {
-        return (_jsx(TeamSelector, { arkApiClient: arkApiClient, onSelect: (team) => {
-                // Update the target to the selected team
+        return (_jsx(TargetSelector, { targets: teams, title: "Select Team", subtitle: "Choose a team to start a conversation with", loading: selectorLoading, error: selectorError, formatLabel: (t) => {
+                const team = teams.find((tm) => tm.name === t.name);
+                return team
+                    ? `${team.name}${team.strategy ? ` (${team.strategy})` : ''}`
+                    : t.name;
+            }, formatInlineDetail: (t) => t.description, showDetailPanel: true, onSelect: (target) => {
+                const team = teams.find((tm) => tm.name === target.name);
+                if (!team)
+                    return;
                 const teamTarget = {
                     id: `team/${team.name}`,
                     name: team.name,
@@ -670,7 +736,6 @@ const ChatUI = ({ initialTargetId, arkApiClient, arkApiProxy, config, }) => {
                 setChatConfig((prev) => ({ ...prev, currentTarget: teamTarget }));
                 setMessages([]);
                 setShowTeamSelector(false);
-                // Add system message about the selection
                 const systemMessage = {
                     id: generateMessageId(),
                     type: 'system',
@@ -683,8 +748,10 @@ const ChatUI = ({ initialTargetId, arkApiClient, arkApiProxy, config, }) => {
     }
     // Show tool selector if requested
     if (showToolSelector) {
-        return (_jsx(ToolSelector, { arkApiClient: arkApiClient, onSelect: (tool) => {
-                // Update the target to the selected tool
+        return (_jsx(TargetSelector, { targets: tools, title: "Select Tool", subtitle: "Choose a tool to start a conversation with", loading: selectorLoading, error: selectorError, formatInlineDetail: (t) => t.description, showDetailPanel: true, onSelect: (target) => {
+                const tool = tools.find((tl) => tl.name === target.name);
+                if (!tool)
+                    return;
                 const toolTarget = {
                     id: `tool/${tool.name}`,
                     name: tool.name,
@@ -695,7 +762,6 @@ const ChatUI = ({ initialTargetId, arkApiClient, arkApiProxy, config, }) => {
                 setChatConfig((prev) => ({ ...prev, currentTarget: toolTarget }));
                 setMessages([]);
                 setShowToolSelector(false);
-                // Add system message about the selection
                 const systemMessage = {
                     id: generateMessageId(),
                     type: 'system',

package/dist/index.js

@@ -13,10 +13,13 @@ 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 { createEvaluationCommand } from './commands/evaluation/index.js';
 import { createGenerateCommand } from './commands/generate/index.js';
 import { createInstallCommand } from './commands/install/index.js';
+import { createMemoryCommand } from './commands/memory/index.js';
 import { createModelsCommand } from './commands/models/index.js';
 import { createQueryCommand } from './commands/query/index.js';
+import { createQueriesCommand } from './commands/queries/index.js';
 import { createUninstallCommand } from './commands/uninstall/index.js';
 import { createStatusCommand } from './commands/status/index.js';
 import { createConfigCommand } from './commands/config/index.js';
@@ -43,10 +46,13 @@ async function main() {
     program.addCommand(createCompletionCommand(config));
     program.addCommand(createDashboardCommand(config));
     program.addCommand(createDocsCommand(config));
+    program.addCommand(createEvaluationCommand(config));
     program.addCommand(createGenerateCommand(config));
     program.addCommand(createInstallCommand(config));
+    program.addCommand(createMemoryCommand(config));
     program.addCommand(createModelsCommand(config));
     program.addCommand(createQueryCommand(config));
+    program.addCommand(createQueriesCommand(config));
     program.addCommand(createUninstallCommand(config));
     program.addCommand(createStatusCommand());
     program.addCommand(createConfigCommand(config));

package/dist/lib/arkApiClient.d.ts

@@ -47,6 +47,10 @@ export declare class ArkApiClient {
     getModels(): Promise<Model[]>;
     getTools(): Promise<Tool[]>;
     getTeams(): Promise<Team[]>;
+    getSessions(): Promise<any[]>;
+    deleteSession(sessionId: string): Promise<any>;
+    deleteQueryMessages(sessionId: string, queryId: string): Promise<any>;
+    deleteAllSessions(): Promise<any>;
     createChatCompletion(params: OpenAI.Chat.Completions.ChatCompletionCreateParams): Promise<OpenAI.Chat.Completions.ChatCompletion>;
     createChatCompletionStream(params: OpenAI.Chat.Completions.ChatCompletionCreateParams): AsyncIterable<OpenAI.Chat.Completions.ChatCompletionChunk>;
 }

package/dist/lib/arkApiClient.js

@@ -84,6 +84,61 @@ export class ArkApiClient {
             throw new Error(`Failed to get teams: ${error instanceof Error ? error.message : 'Unknown error'}`);
         }
     }
+    async getSessions() {
+        try {
+            const response = await fetch(`${this.baseUrl}/v1/sessions`);
+            if (!response.ok) {
+                throw new Error(`HTTP error! status: ${response.status}`);
+            }
+            const data = (await response.json());
+            return data.items || [];
+        }
+        catch (error) {
+            throw new Error(`Failed to get sessions: ${error instanceof Error ? error.message : 'Unknown error'}`);
+        }
+    }
+    async deleteSession(sessionId) {
+        try {
+            const response = await fetch(`${this.baseUrl}/v1/sessions/${sessionId}`, {
+                method: 'DELETE',
+            });
+            if (!response.ok) {
+                throw new Error(`HTTP error! status: ${response.status}`);
+            }
+            return await response.json();
+        }
+        catch (error) {
+            throw new Error(`Failed to delete session: ${error instanceof Error ? error.message : 'Unknown error'}`);
+        }
+    }
+    async deleteQueryMessages(sessionId, queryId) {
+        try {
+            const response = await fetch(`${this.baseUrl}/v1/sessions/${sessionId}/queries/${queryId}/messages`, {
+                method: 'DELETE',
+            });
+            if (!response.ok) {
+                throw new Error(`HTTP error! status: ${response.status}`);
+            }
+            return await response.json();
+        }
+        catch (error) {
+            throw new Error(`Failed to delete query messages: ${error instanceof Error ? error.message : 'Unknown error'}`);
+        }
+    }
+    async deleteAllSessions() {
+        try {
+            const response = await fetch(`${this.baseUrl}/v1/sessions`, {
+                method: 'DELETE',
+            });
+            if (!response.ok) {
+                throw new Error(`HTTP error! status: ${response.status}`);
+            }
+            return await response.json();
+        }
+        catch (error) {
+            throw new Error(`Failed to delete all sessions: ${error instanceof Error ? error.message : 'Unknown error'}`);
+        }
+    }
     async createChatCompletion(params) {
         return (await this.openai.chat.completions.create({
             ...params,

package/dist/lib/errors.d.ts

@@ -6,6 +6,7 @@ export declare const ExitCodes: {
     readonly CliError: 1;
     readonly OperationError: 2;
     readonly Timeout: 3;
+    readonly EvaluationFailed: 4;
 };
 export declare enum ErrorCode {
     INVALID_INPUT = "INVALID_INPUT",

package/dist/lib/errors.js

@@ -8,6 +8,7 @@ export const ExitCodes = {
     CliError: 1,
     OperationError: 2,
     Timeout: 3,
+    EvaluationFailed: 4,
 };
 export var ErrorCode;
 (function (ErrorCode) {

package/dist/lib/executeEvaluation.d.ts

@@ -0,0 +1,16 @@
+export interface DirectEvaluationOptions {
+    evaluatorName: string;
+    input: string;
+    output: string;
+    timeout?: string;
+    watchTimeout?: string;
+}
+export interface QueryEvaluationOptions {
+    evaluatorName: string;
+    queryName: string;
+    responseTarget?: string;
+    timeout?: string;
+    watchTimeout?: string;
+}
+export declare function executeDirectEvaluation(options: DirectEvaluationOptions): Promise<void>;
+export declare function executeQueryEvaluation(options: QueryEvaluationOptions): Promise<void>;

package/dist/lib/executeEvaluation.js

@@ -0,0 +1,155 @@
+import { execa } from 'execa';
+import ora from 'ora';
+import chalk from 'chalk';
+import output from './output.js';
+import { ExitCodes } from './errors.js';
+import { parseDuration } from './duration.js';
+async function waitForEvaluationAndDisplayResults(evaluationName, watchTimeoutMs, watchTimeoutDisplay) {
+    const spinner = ora('Waiting for evaluation completion...').start();
+    try {
+        await execa('kubectl', [
+            'wait',
+            '--for=condition=Completed',
+            `evaluation/${evaluationName}`,
+            `--timeout=${Math.floor(watchTimeoutMs / 1000)}s`,
+        ], { timeout: watchTimeoutMs });
+    }
+    catch (error) {
+        spinner.stop();
+        if (error instanceof Error && error.message.includes('timed out waiting')) {
+            console.error(chalk.red(`Evaluation did not complete within ${watchTimeoutDisplay}`));
+            process.exit(ExitCodes.Timeout);
+        }
+        throw error;
+    }
+    spinner.stop();
+    const { stdout } = await execa('kubectl', ['get', 'evaluation', evaluationName, '-o', 'json'], { stdio: 'pipe' });
+    const evaluation = JSON.parse(stdout);
+    const status = evaluation.status;
+    if (status?.phase === 'done') {
+        console.log(chalk.green('\nEvaluation completed successfully:'));
+        if (status.score !== undefined) {
+            console.log(`Score: ${status.score}`);
+        }
+        if (status.passed !== undefined) {
+            console.log(`Result: ${status.passed ? chalk.green('PASSED') : chalk.red('FAILED')}`);
+        }
+        if (status.message) {
+            console.log(`Message: ${status.message}`);
+        }
+    }
+    else if (status?.phase === 'error') {
+        console.error(chalk.red(status.message || 'Evaluation failed with unknown error'));
+        process.exit(ExitCodes.OperationError);
+    }
+    else {
+        output.warning(`Unexpected evaluation phase: ${status?.phase}`);
+    }
+}
+export async function executeDirectEvaluation(options) {
+    const spinner = ora('Creating evaluation...').start();
+    const queryTimeoutMs = options.timeout
+        ? parseDuration(options.timeout)
+        : parseDuration('5m');
+    const watchTimeoutMs = options.watchTimeout
+        ? parseDuration(options.watchTimeout)
+        : queryTimeoutMs + 60000;
+    const timestamp = Date.now();
+    const evaluationName = `cli-eval-${timestamp}`;
+    const evaluationManifest = {
+        apiVersion: 'ark.mckinsey.com/v1alpha1',
+        kind: 'Evaluation',
+        metadata: {
+            name: evaluationName,
+        },
+        spec: {
+            type: 'direct',
+            evaluator: {
+                name: options.evaluatorName,
+            },
+            config: {
+                input: options.input,
+                output: options.output,
+            },
+            ...(options.timeout && { timeout: options.timeout }),
+            ttl: '1h',
+        },
+    };
+    try {
+        spinner.text = 'Submitting evaluation...';
+        await execa('kubectl', ['apply', '-f', '-'], {
+            input: JSON.stringify(evaluationManifest),
+            stdio: ['pipe', 'pipe', 'pipe'],
+        });
+        spinner.stop();
+        const watchTimeoutDisplay = options.watchTimeout ?? `${Math.floor(watchTimeoutMs / 1000)}s`;
+        await waitForEvaluationAndDisplayResults(evaluationName, watchTimeoutMs, watchTimeoutDisplay);
+    }
+    catch (error) {
+        spinner.stop();
+        console.error(chalk.red(error instanceof Error ? error.message : 'Unknown error'));
+        process.exit(ExitCodes.CliError);
+    }
+}
+export async function executeQueryEvaluation(options) {
+    const spinner = ora('Creating evaluation...').start();
+    const queryTimeoutMs = options.timeout
+        ? parseDuration(options.timeout)
+        : parseDuration('5m');
+    const watchTimeoutMs = options.watchTimeout
+        ? parseDuration(options.watchTimeout)
+        : queryTimeoutMs + 60000;
+    const timestamp = Date.now();
+    const evaluationName = `cli-eval-${timestamp}`;
+    let responseTarget;
+    if (options.responseTarget) {
+        const parts = options.responseTarget.split(':');
+        if (parts.length === 2) {
+            responseTarget = {
+                type: parts[0],
+                name: parts[1],
+            };
+        }
+        else {
+            spinner.stop();
+            console.error(chalk.red('Invalid response-target format. Use: type:name (e.g., agent:my-agent)'));
+            process.exit(ExitCodes.CliError);
+        }
+    }
+    const evaluationManifest = {
+        apiVersion: 'ark.mckinsey.com/v1alpha1',
+        kind: 'Evaluation',
+        metadata: {
+            name: evaluationName,
+        },
+        spec: {
+            type: 'query',
+            evaluator: {
+                name: options.evaluatorName,
+            },
+            config: {
+                queryRef: {
+                    name: options.queryName,
+                },
+                ...(responseTarget && { responseTarget }),
+            },
+            ...(options.timeout && { timeout: options.timeout }),
+            ttl: '1h',
+        },
+    };
+    try {
+        spinner.text = 'Submitting evaluation...';
+        await execa('kubectl', ['apply', '-f', '-'], {
+            input: JSON.stringify(evaluationManifest),
+            stdio: ['pipe', 'pipe', 'pipe'],
+        });
+        spinner.stop();
+        const watchTimeoutDisplay = options.watchTimeout ?? `${Math.floor(watchTimeoutMs / 1000)}s`;
+        await waitForEvaluationAndDisplayResults(evaluationName, watchTimeoutMs, watchTimeoutDisplay);
+    }
+    catch (error) {
+        spinner.stop();
+        console.error(chalk.red(error instanceof Error ? error.message : 'Unknown error'));
+        process.exit(ExitCodes.CliError);
+    }
+}

package/dist/lib/executeQuery.d.ts

@@ -9,6 +9,7 @@ export interface QueryOptions {
     timeout?: string;
     watchTimeout?: string;
     verbose?: boolean;
+    outputFormat?: string;
 }
 /**
  * Execute a query against any ARK target (model, agent, team)

package/dist/lib/executeQuery.js

@@ -7,12 +7,15 @@ import chalk from 'chalk';
 import output from './output.js';
 import { ExitCodes } from './errors.js';
 import { parseDuration } from './duration.js';
+import { getResource } from './kubectl.js';
 /**
  * Execute a query against any ARK target (model, agent, team)
  * This is the shared implementation used by all query commands
  */
 export async function executeQuery(options) {
-    const spinner = ora('Creating query...').start();
+    const spinner = options.outputFormat
+        ? null
+        : ora('Creating query...').start();
     const queryTimeoutMs = options.timeout
         ? parseDuration(options.timeout)
         : parseDuration('5m');
@@ -40,13 +43,15 @@ export async function executeQuery(options) {
     };
     try {
         // Apply the query
-        spinner.text = 'Submitting query...';
+        if (spinner)
+            spinner.text = 'Submitting query...';
         await execa('kubectl', ['apply', '-f', '-'], {
             input: JSON.stringify(queryManifest),
             stdio: ['pipe', 'pipe', 'pipe'],
         });
         // Watch for query completion using kubectl wait
-        spinner.text = 'Waiting for query completion...';
+        if (spinner)
+            spinner.text = 'Waiting for query completion...';
         try {
             await execa('kubectl', [
                 'wait',
@@ -56,7 +61,8 @@ export async function executeQuery(options) {
             ], { timeout: watchTimeoutMs });
         }
         catch (error) {
-            spinner.stop();
+            if (spinner)
+                spinner.stop();
             // Check if it's a timeout or other error
             if (error instanceof Error &&
                 error.message.includes('timed out waiting')) {
@@ -65,11 +71,35 @@ export async function executeQuery(options) {
             }
             // For other errors, fetch the query to check status
         }
-        spinner.stop();
+        if (spinner)
+            spinner.stop();
+        // If output format is specified, output the resource and return
+        if (options.outputFormat) {
+            try {
+                if (options.outputFormat === 'name') {
+                    console.log(queryName);
+                }
+                else if (options.outputFormat === 'json' ||
+                    options.outputFormat === 'yaml') {
+                    const { stdout } = await execa('kubectl', ['get', 'query', queryName, '-o', options.outputFormat], { stdio: 'pipe' });
+                    console.log(stdout);
+                }
+                else {
+                    console.error(chalk.red(`Invalid output format: ${options.outputFormat}. Use: yaml, json, or name`));
+                    process.exit(ExitCodes.CliError);
+                }
+                return;
+            }
+            catch (error) {
+                console.error(chalk.red(error instanceof Error
+                    ? error.message
+                    : 'Failed to fetch query resource'));
+                process.exit(ExitCodes.CliError);
+            }
+        }
         // Fetch final query state
         try {
-            const { stdout } = await execa('kubectl', ['get', 'query', queryName, '-o', 'json'], { stdio: 'pipe' });
-            const query = JSON.parse(stdout);
+            const query = await getResource('queries', queryName);
             const phase = query.status?.phase;
             // Check if query completed successfully or with error
             if (phase === 'done') {
@@ -88,7 +118,12 @@ export async function executeQuery(options) {
                 process.exit(ExitCodes.OperationError);
             }
             else if (phase === 'canceled') {
-                spinner.warn('Query canceled');
+                if (spinner) {
+                    spinner.warn('Query canceled');
+                }
+                else {
+                    output.warning('Query canceled');
+                }
                 if (query.status?.message) {
                     output.warning(query.status.message);
                 }
@@ -96,12 +131,15 @@ export async function executeQuery(options) {
             }
         }
         catch (error) {
-            console.error(chalk.red(error instanceof Error ? error.message : 'Failed to fetch query result'));
+            console.error(chalk.red(error instanceof Error
+                ? error.message
+                : 'Failed to fetch query result'));
             process.exit(ExitCodes.CliError);
         }
     }
     catch (error) {
-        spinner.stop();
+        if (spinner)
+            spinner.stop();
         console.error(chalk.red(error instanceof Error ? error.message : 'Unknown error'));
         process.exit(ExitCodes.CliError);
     }

package/dist/lib/executeQuery.spec.js

@@ -69,7 +69,7 @@ describe('executeQuery', () => {
                 if (args.includes('apply')) {
                     return { stdout: '', stderr: '', exitCode: 0 };
                 }
-                if (args.includes('get') && args.includes('query')) {
+                if (args.includes('get') && args.includes('queries')) {
                     return {
                         stdout: JSON.stringify(mockQueryResponse),
                         stderr: '',
@@ -98,7 +98,7 @@ describe('executeQuery', () => {
                 if (args.includes('apply')) {
                     return { stdout: '', stderr: '', exitCode: 0 };
                 }
-                if (args.includes('get') && args.includes('query')) {
+                if (args.includes('get') && args.includes('queries')) {
                     return {
                         stdout: JSON.stringify(mockQueryResponse),
                         stderr: '',
@@ -132,7 +132,7 @@ describe('executeQuery', () => {
                 if (args.includes('apply')) {
                     return { stdout: '', stderr: '', exitCode: 0 };
                 }
-                if (args.includes('get') && args.includes('query')) {
+                if (args.includes('get') && args.includes('queries')) {
                     return {
                         stdout: JSON.stringify(mockQueryResponse),
                         stderr: '',

package/dist/lib/kubectl.d.ts

@@ -0,0 +1,8 @@
+interface K8sResource {
+    metadata: {
+        name: string;
+        creationTimestamp?: string;
+    };
+}
+export declare function getResource<T extends K8sResource>(resourceType: string, name: string): Promise<T>;
+export {};

package/dist/lib/kubectl.js

@@ -0,0 +1,20 @@
+import { execa } from 'execa';
+export async function getResource(resourceType, name) {
+    if (name === '@latest') {
+        const result = await execa('kubectl', [
+            'get',
+            resourceType,
+            '--sort-by=.metadata.creationTimestamp',
+            '-o',
+            'json',
+        ], { stdio: 'pipe' });
+        const data = JSON.parse(result.stdout);
+        const resources = data.items || [];
+        if (resources.length === 0) {
+            throw new Error(`No ${resourceType} found`);
+        }
+        return resources[resources.length - 1];
+    }
+    const result = await execa('kubectl', ['get', resourceType, name, '-o', 'json'], { stdio: 'pipe' });
+    return JSON.parse(result.stdout);
+}

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

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