@ruska/cli 0.1.2 → 0.1.4

package/README.md

@@ -35,18 +35,23 @@ $ ruska --help
     auth              Configure API authentication
     assistants        List your assistants
     assistant <id>    Get assistant by ID
-    chat <message>    Chat with an assistant or continue a thread
+    chat <message>    Chat with the LLM (optionally with an assistant)
     create            Create a new assistant
     models            List available models
+    version           Show CLI and API version
+    health            Check API health status
 
   Options
     --ui              Launch interactive TUI mode
 
   Chat Options
-    -a, --assistant   Assistant ID for new conversations
+    -a, --assistant   Assistant ID (optional, uses default chat if omitted)
     -t, --thread      Thread ID to continue a conversation
     -m, --message     Message (alternative to positional arg)
     --json            Output as newline-delimited JSON (auto-enabled when piped)
+    --truncate <n>    Max characters for tool output (default: 500)
+    --truncate-lines  Max lines for tool output (default: 10)
+    --full-output     Disable truncation (show full output)
 
   Create Options
     --name            Assistant name (required)
@@ -59,8 +64,9 @@ $ ruska --help
   Examples
     $ ruska auth                                    # Configure API key and host
     $ ruska assistants                              # List your assistants
-    $ ruska assistant eed8d8b3-3dcd-4396-afba-...   # Get assistant details
-    $ ruska chat "Hello" -a <assistant-id>         # New conversation with assistant
+    $ ruska assistant abc-123                       # Get assistant details
+    $ ruska chat "Hello"                           # Direct chat with default LLM
+    $ ruska chat "Hello" -a <assistant-id>         # Chat with specific assistant
     $ ruska chat "Follow up" -t <thread-id>        # Continue existing thread
     $ ruska chat "Hello" -a <id> --json            # Output as NDJSON
     $ ruska chat "Query" -a <id> | jq '.type'      # Pipe to jq
@@ -128,7 +134,13 @@ Tools: get_exchange_rate, convert_currency
 
 ### `ruska chat <message>`
 
-Chat with an assistant or continue a thread using streaming. Requires authentication.
+Chat with the LLM (optionally with an assistant) using streaming. Requires authentication.
+
+**Direct chat with default LLM:**
+
+```bash
+$ ruska chat "Hello, how are you?"
+```
 
 **Start a new conversation with an assistant:**
 
@@ -159,12 +171,15 @@ $ ruska chat "Hello" -a <assistant-id> | jq '.type'
 
 **Options:**
 
-| Option            | Description                                     |
-| ----------------- | ----------------------------------------------- |
-| `-a, --assistant` | Assistant ID for new conversations              |
-| `-t, --thread`    | Thread ID to continue an existing conversation  |
-| `-m, --message`   | Message to send (alternative to positional arg) |
-| `--json`          | Output as newline-delimited JSON (NDJSON)       |
+| Option             | Description                                           |
+| ------------------ | ----------------------------------------------------- |
+| `-a, --assistant`  | Assistant ID (optional, uses default chat if omitted) |
+| `-t, --thread`     | Thread ID to continue an existing conversation        |
+| `-m, --message`    | Message to send (alternative to positional arg)       |
+| `--json`           | Output as newline-delimited JSON (NDJSON)             |
+| `--truncate <n>`   | Max characters for tool output (default: 500)         |
+| `--truncate-lines` | Max lines for tool output (default: 10)               |
+| `--full-output`    | Disable truncation (show full output)                 |
 
 **Exit codes:**
 
@@ -228,6 +243,28 @@ All Models (15):
  ...
 ```
 
+### `ruska version`
+
+Show CLI and API version information.
+
+```bash
+$ ruska version
+
+Ruska CLI v0.1.3
+API: https://chat.ruska.ai
+```
+
+### `ruska health`
+
+Check API health status.
+
+```bash
+$ ruska health
+
+API Health Check
+Status: healthy
+```
+
 ### `ruska --ui`
 
 Launch the interactive TUI (Terminal User Interface) mode with a full-screen interface.

package/dist/cli.js

@@ -10,6 +10,8 @@ import { runAssistantCommand } from './commands/assistant.js';
 import { runModelsCommand } from './commands/models.js';
 import { runCreateAssistantCommand } from './commands/create-assistant.js';
 import { runChatCommand } from './commands/chat.js';
+import { runVersionCommand } from './commands/version.js';
+import { runHealthCommand } from './commands/health.js';
 const cli = meow(`
 	Usage
 	  $ ruska <command> [options]
@@ -18,18 +20,23 @@ const cli = meow(`
 	  auth              Configure API authentication
 	  assistants        List your assistants
 	  assistant <id>    Get assistant by ID
-	  chat <message>    Chat with an assistant or continue a thread
+	  chat <message>    Chat with the LLM (optionally with an assistant)
 	  create            Create a new assistant
 	  models            List available models
+	  version           Show CLI and API version
+	  health            Check API health status
 
 	Options
 	  --ui              Launch interactive TUI mode
 
 	Chat Options
-	  -a, --assistant   Assistant ID for new conversations
+	  -a, --assistant   Assistant ID (optional, uses default chat if omitted)
 	  -t, --thread      Thread ID to continue a conversation
 	  -m, --message     Message (alternative to positional arg)
 	  --json            Output as newline-delimited JSON (auto-enabled when piped)
+	  --truncate <n>    Max characters for tool output (default: 500)
+	  --truncate-lines  Max lines for tool output (default: 10)
+	  --full-output     Disable truncation (show full output)
 
 	Create Options
 	  --name            Assistant name (required)
@@ -43,7 +50,8 @@ const cli = meow(`
 	  $ ruska auth                                    # Configure API key and host
 	  $ ruska assistants                              # List your assistants
 	  $ ruska assistant abc-123                       # Get assistant details
-	  $ ruska chat "Hello" -a <assistant-id>         # New conversation with assistant
+	  $ ruska chat "Hello"                           # Direct chat with default LLM
+	  $ ruska chat "Hello" -a <assistant-id>         # Chat with specific assistant
 	  $ ruska chat "Follow up" -t <thread-id>        # Continue existing thread
 	  $ ruska chat "Hello" -a <id> --json            # Output as NDJSON
 	  $ ruska chat "Query" -a <id> | jq '.type'      # Pipe to jq
@@ -74,6 +82,18 @@ const cli = meow(`
             type: 'string',
             shortFlag: 't',
         },
+        truncate: {
+            type: 'number',
+            default: 500,
+        },
+        truncateLines: {
+            type: 'number',
+            default: 10,
+        },
+        fullOutput: {
+            type: 'boolean',
+            default: false,
+        },
         interactive: {
             type: 'boolean',
             shortFlag: 'i',
@@ -134,29 +154,21 @@ async function main() {
             const threadId = cli.flags.thread ??
                 cli.flags['t']?.toString();
             const message = args.join(' ') || cli.flags.message;
-            // Require either assistant or thread
-            if (!assistantId && !threadId) {
-                console.error('Usage: ruska chat "<message>" -a <assistant-id>');
-                console.error('       ruska chat "<message>" -t <thread-id>');
-                console.log('');
-                console.log('Options:');
-                console.log('  -a, --assistant   Assistant ID for new conversations');
-                console.log('  -t, --thread      Thread ID to continue a conversation');
-                console.log('');
-                console.log('Examples:');
-                console.log('  ruska chat "Hello" -a abc-123');
-                console.log('  ruska chat "Follow up" -t thread-456');
-                process.exit(1);
-            }
             if (!message) {
                 console.error('Error: Message is required');
-                console.error('Usage: ruska chat "<message>" -a <assistant-id>');
+                console.error('Usage: ruska chat "<message>" [-a <assistant-id>]');
                 process.exit(1);
             }
             await runChatCommand(message, {
                 json: cli.flags.json,
                 assistantId,
                 threadId,
+                truncateOptions: cli.flags.fullOutput
+                    ? undefined
+                    : {
+                        maxLength: cli.flags.truncate,
+                        maxLines: cli.flags.truncateLines,
+                    },
             });
             break;
         }
@@ -174,6 +186,14 @@ async function main() {
             });
             break;
         }
+        case 'version': {
+            await runVersionCommand();
+            break;
+        }
+        case 'health': {
+            await runHealthCommand();
+            break;
+        }
         case 'help':
         case undefined: {
             cli.showHelp();

package/dist/commands/chat.d.ts

@@ -2,6 +2,7 @@
  * Chat command for streaming LLM responses
  * Implements Golden Path: Beta architecture + Gamma output + Alpha timeout
  */
+import { type TruncateOptions } from '../lib/output/truncate.js';
 /**
  * Run the chat command
  */
@@ -9,4 +10,5 @@ export declare function runChatCommand(message: string, options?: {
     json?: boolean;
     assistantId?: string;
     threadId?: string;
+    truncateOptions?: TruncateOptions;
 }): Promise<void>;

package/dist/commands/chat.js

@@ -13,6 +13,7 @@ import { OutputFormatter } from '../lib/output/formatter.js';
 import { classifyError, exitCodes } from '../lib/output/error-handler.js';
 import { writeJson, checkIsTty } from '../lib/output/writers.js';
 import { StreamService, StreamConnectionError, } from '../lib/services/stream-service.js';
+import { truncate } from '../lib/output/truncate.js';
 /**
  * Group messages into blocks by type + name boundaries
  */
@@ -42,6 +43,21 @@ function groupMessagesIntoBlocks(messages) {
     }
     return blocks;
 }
+/**
+ * Extract model name from stream events
+ */
+function extractModelFromEvents(events) {
+    for (let i = events.length - 1; i >= 0; i--) {
+        const event = events[i];
+        if (event?.type === 'messages') {
+            const message = event.payload[0];
+            const modelName = message?.response_metadata?.['model_name'];
+            if (modelName)
+                return String(modelName);
+        }
+    }
+    return undefined;
+}
 /**
  * Status indicator component for TUI mode
  */
@@ -67,7 +83,7 @@ function StatusIndicator({ status }) {
 /**
  * TUI mode chat command using React hook
  */
-function ChatCommandTui({ message, assistantId, threadId, }) {
+function ChatCommandTui({ message, assistantId, threadId, truncateOptions, }) {
     const { exit } = useApp();
     const [config, setConfig] = useState();
     const [authError, setAuthError] = useState(false);
@@ -98,7 +114,7 @@ function ChatCommandTui({ message, assistantId, threadId, }) {
         : undefined, [config, assistantId, message, threadId]);
     /* eslint-enable @typescript-eslint/naming-convention */
     // Stream
-    const { status, messages, error } = useStream(config, request);
+    const { status, messages, events, error } = useStream(config, request);
     // Group messages into blocks by type + name boundaries
     const messageBlocks = useMemo(() => groupMessagesIntoBlocks(messages), [messages]);
     // Exit on completion
@@ -132,10 +148,27 @@ function ChatCommandTui({ message, assistantId, threadId, }) {
             React.createElement(Text, { dimColor: true, color: "cyan" },
                 "Tool Output",
                 block.name ? `: ${block.name}` : ''),
-            React.createElement(Box, { marginLeft: 2 },
-                React.createElement(Text, { dimColor: true }, block.content)))) : (React.createElement(Text, null, block.content))))),
-        status === 'done' && (React.createElement(Box, { marginTop: 1 },
-            React.createElement(Text, { color: "green" }, "Done")))));
+            React.createElement(Box, { marginLeft: 2, flexDirection: "column" }, (() => {
+                if (!truncateOptions) {
+                    return React.createElement(Text, { dimColor: true }, block.content);
+                }
+                const result = truncate(block.content, truncateOptions);
+                return (React.createElement(React.Fragment, null,
+                    React.createElement(Text, { dimColor: true }, result.text),
+                    result.wasTruncated && (React.createElement(Text, { dimColor: true, color: "yellow" }, "(use --full-output for full output)"))));
+            })()))) : (React.createElement(Text, null, block.content))))),
+        status === 'done' && (React.createElement(Box, { marginTop: 1, flexDirection: "column" },
+            React.createElement(Text, { color: "green" }, "Done"),
+            request?.metadata?.thread_id && (React.createElement(Text, { dimColor: true },
+                "Thread: ",
+                request.metadata.thread_id)),
+            extractModelFromEvents(events) && (React.createElement(Text, { dimColor: true },
+                "Model: ",
+                extractModelFromEvents(events))),
+            request?.metadata?.thread_id && (React.createElement(Text, { dimColor: true },
+                "Continue: ruska chat \"message\" -t",
+                ' ',
+                request.metadata.thread_id))))));
 }
 /**
  * JSON mode chat command - direct streaming without React hooks
@@ -211,7 +244,7 @@ async function runJsonMode(message, assistantId, threadId) {
 /**
  * Main chat command component - handles JSON mode branching
  */
-function ChatCommand({ message, isJsonMode, assistantId, threadId, }) {
+function ChatCommand({ message, isJsonMode, assistantId, threadId, truncateOptions, }) {
     const { exit } = useApp();
     useEffect(() => {
         if (isJsonMode) {
@@ -226,7 +259,7 @@ function ChatCommand({ message, isJsonMode, assistantId, threadId, }) {
         return null;
     }
     // TUI mode
-    return (React.createElement(ChatCommandTui, { message: message, assistantId: assistantId, threadId: threadId }));
+    return (React.createElement(ChatCommandTui, { message: message, assistantId: assistantId, threadId: threadId, truncateOptions: truncateOptions }));
 }
 /**
  * Run the chat command
@@ -234,6 +267,6 @@ function ChatCommand({ message, isJsonMode, assistantId, threadId, }) {
 export async function runChatCommand(message, options = {}) {
     // Auto-detect: use JSON mode if not TTY (piped) or explicitly requested
     const isJsonMode = options.json ?? !checkIsTty();
-    const { waitUntilExit } = render(React.createElement(ChatCommand, { message: message, isJsonMode: isJsonMode, assistantId: options.assistantId, threadId: options.threadId }));
+    const { waitUntilExit } = render(React.createElement(ChatCommand, { message: message, isJsonMode: isJsonMode, assistantId: options.assistantId, threadId: options.threadId, truncateOptions: options.truncateOptions }));
     await waitUntilExit();
 }

package/dist/commands/health.d.ts

@@ -0,0 +1 @@
+export declare function runHealthCommand(): Promise<void>;

package/dist/commands/health.js

@@ -0,0 +1,78 @@
+import React, { useState, useEffect } from 'react';
+import { render, Text, Box, useApp } from 'ink';
+import Spinner from 'ink-spinner';
+import { hostPresets } from '../types/index.js';
+import { loadConfig } from '../lib/config.js';
+import { fetchHealth } from '../lib/api.js';
+function HealthCommand() {
+    const { exit } = useApp();
+    const [status, setStatus] = useState('loading');
+    const [health, setHealth] = useState(undefined);
+    const [error, setError] = useState(undefined);
+    const [host, setHost] = useState('');
+    useEffect(() => {
+        const checkHealth = async () => {
+            // Try to load config for host, fall back to production
+            const config = await loadConfig();
+            const targetHost = config?.host ?? hostPresets.production;
+            setHost(targetHost);
+            // Fetch health status
+            const result = await fetchHealth(targetHost);
+            if (result.success && result.data) {
+                setHealth(result.data);
+                setStatus('success');
+            }
+            else {
+                setError(result.error ?? 'Failed to fetch health status');
+                setStatus('error');
+            }
+            setTimeout(() => {
+                exit();
+            }, 100);
+        };
+        void checkHealth();
+    }, [exit]);
+    if (status === 'loading') {
+        return (React.createElement(Box, null,
+            React.createElement(Text, { color: "cyan" },
+                React.createElement(Spinner, { type: "dots" })),
+            React.createElement(Text, null, " Checking health...")));
+    }
+    if (status === 'error') {
+        return (React.createElement(Box, { flexDirection: "column" },
+            React.createElement(Box, { marginBottom: 1 },
+                React.createElement(Text, { bold: true, color: "cyan" }, "Health Check"),
+                React.createElement(Text, { dimColor: true },
+                    " (",
+                    host,
+                    ")")),
+            React.createElement(Text, null,
+                React.createElement(Text, { dimColor: true }, "Status: "),
+                React.createElement(Text, { bold: true, color: "red" }, "unhealthy")),
+            React.createElement(Text, null,
+                React.createElement(Text, { dimColor: true }, "Error: "),
+                React.createElement(Text, { color: "red" }, error))));
+    }
+    // Success - display health info
+    const statusColor = health?.status === 'healthy' ? 'green' : 'yellow';
+    return (React.createElement(Box, { flexDirection: "column" },
+        React.createElement(Box, { marginBottom: 1 },
+            React.createElement(Text, { bold: true, color: "cyan" }, "Health Check"),
+            React.createElement(Text, { dimColor: true },
+                " (",
+                host,
+                ")")),
+        React.createElement(Text, null,
+            React.createElement(Text, { dimColor: true }, "Status: "),
+            React.createElement(Text, { bold: true, color: statusColor }, health?.status)),
+        React.createElement(Text, null,
+            React.createElement(Text, { dimColor: true }, "Message: "),
+            React.createElement(Text, null, health?.message)),
+        React.createElement(Text, null,
+            React.createElement(Text, { dimColor: true }, "Version: "),
+            React.createElement(Text, null, health?.version))));
+}
+export async function runHealthCommand() {
+    const { waitUntilExit } = render(React.createElement(HealthCommand, null));
+    await waitUntilExit();
+}

package/dist/commands/version.d.ts

@@ -0,0 +1 @@
+export declare function runVersionCommand(): Promise<void>;

package/dist/commands/version.js

@@ -0,0 +1,68 @@
+import React, { useState, useEffect } from 'react';
+import { render, Text, Box, useApp } from 'ink';
+import Spinner from 'ink-spinner';
+import { hostPresets } from '../types/index.js';
+import { loadConfig } from '../lib/config.js';
+import { fetchHealth } from '../lib/api.js';
+const cliVersion = '0.1.3';
+function VersionCommand() {
+    const { exit } = useApp();
+    const [status, setStatus] = useState('loading');
+    const [health, setHealth] = useState(undefined);
+    const [error, setError] = useState(undefined);
+    const [host, setHost] = useState('');
+    useEffect(() => {
+        const getVersion = async () => {
+            // Try to load config for host, fall back to production
+            const config = await loadConfig();
+            const targetHost = config?.host ?? hostPresets.production;
+            setHost(targetHost);
+            // Fetch health to get API version
+            const result = await fetchHealth(targetHost);
+            if (result.success && result.data) {
+                setHealth(result.data);
+                setStatus('success');
+            }
+            else {
+                setError(result.error ?? 'Failed to fetch API version');
+                setStatus('error');
+            }
+            setTimeout(() => {
+                exit();
+            }, 100);
+        };
+        void getVersion();
+    }, [exit]);
+    if (status === 'loading') {
+        return (React.createElement(Box, null,
+            React.createElement(Text, { color: "cyan" },
+                React.createElement(Spinner, { type: "dots" })),
+            React.createElement(Text, null, " Loading version info...")));
+    }
+    // Always show CLI version
+    return (React.createElement(Box, { flexDirection: "column" },
+        React.createElement(Text, null,
+            React.createElement(Text, { bold: true, color: "cyan" }, "@ruska/cli"),
+            React.createElement(Text, null,
+                " v",
+                cliVersion)),
+        status === 'error' ? (React.createElement(Text, null,
+            React.createElement(Text, { bold: true }, "API:"),
+            React.createElement(Text, { color: "red" }, " unavailable"),
+            React.createElement(Text, { dimColor: true },
+                " (",
+                error,
+                ")"))) : (React.createElement(Text, null,
+            React.createElement(Text, { bold: true }, "API:"),
+            React.createElement(Text, { color: "green" },
+                " v",
+                health?.version),
+            React.createElement(Text, { dimColor: true },
+                " (",
+                host,
+                ")")))));
+}
+export async function runVersionCommand() {
+    const { waitUntilExit } = render(React.createElement(VersionCommand, null));
+    await waitUntilExit();
+}

package/dist/lib/api.d.ts

@@ -1,4 +1,4 @@
-import { type Config, type ApiResponse, type UserInfo, type AssistantsSearchResponse, type ModelsResponse, type CreateAssistantRequest, type CreateAssistantResponse } from '../types/index.js';
+import { type Config, type ApiResponse, type UserInfo, type AssistantsSearchResponse, type ModelsResponse, type HealthResponse, type CreateAssistantRequest, type CreateAssistantResponse } from '../types/index.js';
 /**
  * API client for making authenticated requests to the Orchestra backend
  */
@@ -39,3 +39,7 @@ export declare function validateApiKey(host: string, apiKey: string): Promise<Ap
  * Fetch available models (no auth required)
  */
 export declare function fetchModels(host: string, apiKey?: string): Promise<ApiResponse<ModelsResponse>>;
+/**
+ * Fetch health status (no auth required)
+ */
+export declare function fetchHealth(host: string): Promise<ApiResponse<HealthResponse>>;

package/dist/lib/api.js

@@ -149,3 +149,42 @@ export async function fetchModels(host, apiKey) {
         };
     }
 }
+/**
+ * Fetch health status (no auth required)
+ */
+export async function fetchHealth(host) {
+    const url = `${host.replace(/\/$/, '')}/api/info/health`;
+    try {
+        const response = await fetch(url, {
+            headers: {
+                'Content-Type': 'application/json',
+            },
+        });
+        if (!response.ok) {
+            const errorText = await response.text();
+            let errorMessage;
+            try {
+                const errorJson = JSON.parse(errorText);
+                errorMessage = errorJson.detail ?? `HTTP ${response.status}`;
+            }
+            catch {
+                errorMessage = errorText || `HTTP ${response.status}`;
+            }
+            return {
+                success: false,
+                error: errorMessage,
+            };
+        }
+        const data = (await response.json());
+        return {
+            success: true,
+            data,
+        };
+    }
+    catch (error) {
+        return {
+            success: false,
+            error: error instanceof Error ? error.message : 'Unknown error occurred',
+        };
+    }
+}

package/dist/lib/output/truncate.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Truncation utilities for CLI output
+ */
+export type TruncateOptions = {
+    maxLength?: number;
+    maxLines?: number;
+    indicator?: string;
+};
+/**
+ * Truncate text by both line count and character count
+ * Applies line truncation first, then character truncation
+ */
+export declare function truncate(input: string, options?: TruncateOptions): {
+    text: string;
+    wasTruncated: boolean;
+};

package/dist/lib/output/truncate.js

@@ -0,0 +1,53 @@
+/**
+ * Truncation utilities for CLI output
+ */
+const defaults = {
+    maxLength: 500,
+    maxLines: 10,
+    indicator: '... [truncated]',
+};
+/**
+ * Truncate text by line count
+ */
+function truncateByLines(input, maxLines, indicator) {
+    const lines = input.split('\n');
+    if (lines.length <= maxLines) {
+        return { text: input, wasTruncated: false };
+    }
+    const truncated = lines.slice(0, maxLines).join('\n') + '\n' + indicator;
+    return { text: truncated, wasTruncated: true };
+}
+/**
+ * Truncate text by character count
+ */
+function truncateByLength(input, maxLength, indicator) {
+    if (input.length <= maxLength) {
+        return { text: input, wasTruncated: false };
+    }
+    const allowedLength = maxLength - indicator.length;
+    if (allowedLength <= 0) {
+        return { text: indicator, wasTruncated: true };
+    }
+    const truncated = input.slice(0, allowedLength) + indicator;
+    return { text: truncated, wasTruncated: true };
+}
+/**
+ * Truncate text by both line count and character count
+ * Applies line truncation first, then character truncation
+ */
+export function truncate(input, options = {}) {
+    const maxLength = options.maxLength ?? defaults.maxLength;
+    const maxLines = options.maxLines ?? defaults.maxLines;
+    const indicator = options.indicator ?? defaults.indicator;
+    // Apply line truncation first
+    const result = truncateByLines(input, maxLines, indicator);
+    // Then apply character truncation
+    if (result.text.length > maxLength) {
+        const charResult = truncateByLength(result.text, maxLength, indicator);
+        return {
+            text: charResult.text,
+            wasTruncated: result.wasTruncated || charResult.wasTruncated,
+        };
+    }
+    return result;
+}

package/dist/types/index.d.ts

@@ -79,6 +79,14 @@ export type ModelsResponse = {
     free: string[];
     models: string[];
 };
+/**
+ * Response from GET /api/health
+ */
+export type HealthResponse = {
+    status: string;
+    message: string;
+    version: string;
+};
 /**
  * Host presets for environment selection
  */

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@ruska/cli",
-	"version": "0.1.2",
+	"version": "0.1.4",
 	"description": "CLI for Orchestra - AI Agent Orchestration Platform",
 	"license": "Apache-2.0",
 	"author": "RUSKA <reggleston@ruska.ai>",