@syrin/cli 1.3.0

package/dist/presentation/dev/goodbye-messages.js

@@ -0,0 +1,100 @@
+/**
+ * Goodbye message generator for dev mode.
+ * Generates funny, shareable goodbye messages when users exit.
+ */
+/**
+ * Pre-written goodbye messages for users who didn't test anything.
+ */
+const DEFAULT_GOODBYE_MESSAGES = [
+    "👋 Thanks for dropping by! Hope you'll come back to test some tools soon!",
+    "🚀 See you later! Don't forget to test those MCP tools when you're ready!",
+    '✨ Until next time! Your tools are waiting for you!',
+    '🎯 Catch you later! Ready to test when you are!',
+    '💫 Farewell! Come back when you want to see those tools in action!',
+    '🌟 Goodbye! Your MCP server is ready whenever you are!',
+    '🎉 See you soon! Time to make those tools shine!',
+    '🔥 Later! The tools are ready when you are!',
+];
+/**
+ * Generate a funny, shareable goodbye message using LLM.
+ */
+async function generateLLMGoodbyeMessage(llmProvider, sessionState) {
+    const toolCallsCount = sessionState.totalToolCalls;
+    const toolNames = sessionState.toolCalls
+        .map(tc => tc.name)
+        .filter((name, index, self) => self.indexOf(name) === index)
+        .slice(0, 5); // Limit to first 5 unique tool names
+    const sessionDuration = Math.round((Date.now() - sessionState.startTime.getTime()) / 1000);
+    const prompt = `You are a witty, humorous AI assistant. A developer just finished testing their MCP (Model Context Protocol) tools using Syrin, a debugging/testing tool.
+
+Context:
+- They tested ${toolCallsCount} tool${toolCallsCount !== 1 ? 's' : ''} in total
+- Tool names tested: ${toolNames.length > 0 ? toolNames.join(', ') : 'various tools'}
+- Session duration: ${sessionDuration} second${sessionDuration !== 1 ? 's' : ''}
+
+Generate a funny, witty, and shareable goodbye message (2-3 sentences max). The message should:
+1. Be humorous and natural
+2. Reference what they tested in a clever way
+3. Be something they'd want to share on social media (like "look what Syrin told me!")
+4. Feel personal and engaging
+5. Be cool and memorable
+
+Keep it concise, funny, and make it feel like a natural conversation ending. Don't be overly technical - be witty and relatable.
+
+Respond with ONLY the goodbye message, no quotes, no prefixes, just the message text.`;
+    try {
+        const response = await llmProvider.chat({
+            messages: [
+                {
+                    role: 'user',
+                    content: prompt,
+                },
+            ],
+            temperature: 0.9, // Higher temperature for more creativity
+            maxTokens: 150,
+        });
+        // Extract text content from response
+        const content = response.content;
+        if (typeof content === 'string' && content.trim()) {
+            return content.trim();
+        }
+        // Fallback if response format is unexpected
+        return getRandomDefaultMessage();
+    }
+    catch (error) {
+        // If LLM call fails, fall back to default message
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        console.error('Failed to generate LLM goodbye message:', errorMessage);
+        return getRandomDefaultMessage();
+    }
+}
+/**
+ * Get a random default goodbye message.
+ */
+function getRandomDefaultMessage() {
+    const randomIndex = Math.floor(Math.random() * DEFAULT_GOODBYE_MESSAGES.length);
+    return DEFAULT_GOODBYE_MESSAGES[randomIndex];
+}
+/**
+ * Generate an appropriate goodbye message based on session activity.
+ *
+ * @param llmProvider - LLM provider to use for generating funny messages (can be minimal interface)
+ * @param sessionState - Current session state
+ * @returns Promise resolving to goodbye message string
+ */
+export async function generateGoodbyeMessage(llmProvider, sessionState) {
+    // If user tested tools, try to generate a funny LLM message
+    if (sessionState.totalToolCalls > 0 && llmProvider) {
+        try {
+            return await generateLLMGoodbyeMessage(llmProvider, sessionState);
+        }
+        catch (error) {
+            // Fallback to default if LLM generation fails
+            console.error('Error generating LLM goodbye message:', error);
+            return getRandomDefaultMessage();
+        }
+    }
+    // If no tools tested or no LLM provider, use default messages
+    return getRandomDefaultMessage();
+}
+//# sourceMappingURL=goodbye-messages.js.map

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

@@ -0,0 +1,5 @@
+/**
+ * Dev Mode presentation layer exports.
+ */
+export * from './chat-ui.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/presentation/dev/index.js

@@ -0,0 +1,5 @@
+/**
+ * Dev Mode presentation layer exports.
+ */
+export * from './chat-ui.js';
+//# sourceMappingURL=index.js.map

package/dist/presentation/dev/text-wrapper.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Text wrapping utility for user messages.
+ */
+/**
+ * Wrap text to fit within a specified width.
+ *
+ * This function guarantees at least one line in the result. When the input is empty
+ * or contains only whitespace, it returns `['']` (a single empty string) rather than an empty array.
+ * This behavior ensures consistent handling in UI components that expect at least one line
+ * to render, preventing layout issues when displaying wrapped text.
+ *
+ * @param text - The text to wrap
+ * @param width - Maximum width per line
+ * @returns Array of wrapped lines. Always contains at least one element; returns `['']` for empty or whitespace-only input.
+ *
+ * @example
+ * // Normal text wrapping
+ * wrapText('Hello world', 5) // Returns ['Hello', 'world']
+ *
+ * @example
+ * // Empty input returns single empty line
+ * wrapText('', 10) // Returns ['']
+ * wrapText('   ', 10) // Returns [''] (whitespace-only)
+ *
+ * @example
+ * // Long words are split across lines
+ * wrapText('supercalifragilistic', 5) // Returns ['super', 'calif', 'ragil', 'istic']
+ */
+export declare function wrapText(text: string, width: number): string[];
+//# sourceMappingURL=text-wrapper.d.ts.map

package/dist/presentation/dev/text-wrapper.js

@@ -0,0 +1,74 @@
+/**
+ * Text wrapping utility for user messages.
+ */
+/**
+ * Wrap text to fit within a specified width.
+ *
+ * This function guarantees at least one line in the result. When the input is empty
+ * or contains only whitespace, it returns `['']` (a single empty string) rather than an empty array.
+ * This behavior ensures consistent handling in UI components that expect at least one line
+ * to render, preventing layout issues when displaying wrapped text.
+ *
+ * @param text - The text to wrap
+ * @param width - Maximum width per line
+ * @returns Array of wrapped lines. Always contains at least one element; returns `['']` for empty or whitespace-only input.
+ *
+ * @example
+ * // Normal text wrapping
+ * wrapText('Hello world', 5) // Returns ['Hello', 'world']
+ *
+ * @example
+ * // Empty input returns single empty line
+ * wrapText('', 10) // Returns ['']
+ * wrapText('   ', 10) // Returns [''] (whitespace-only)
+ *
+ * @example
+ * // Long words are split across lines
+ * wrapText('supercalifragilistic', 5) // Returns ['super', 'calif', 'ragil', 'istic']
+ */
+export function wrapText(text, width) {
+    const words = text.split(/\s+/);
+    const lines = [];
+    let currentLine = '';
+    for (const word of words) {
+        // Skip empty tokens
+        if (word === '') {
+            continue;
+        }
+        // Handle words longer than width
+        if (word.length > width) {
+            // Push current line if non-empty before inserting chunks
+            if (currentLine) {
+                lines.push(currentLine);
+                currentLine = '';
+            }
+            // Split word into chunks of size <= width
+            for (let i = 0; i < word.length; i += width) {
+                const chunk = word.substring(i, i + width);
+                if (chunk.length === width) {
+                    // Full chunk - append as its own line
+                    lines.push(chunk);
+                }
+                else {
+                    // Remaining partial chunk - start new currentLine
+                    currentLine = chunk;
+                }
+            }
+        }
+        else {
+            // Normal word handling
+            if (currentLine.length + word.length + 1 <= width) {
+                currentLine += (currentLine ? ' ' : '') + word;
+            }
+            else {
+                if (currentLine)
+                    lines.push(currentLine);
+                currentLine = word;
+            }
+        }
+    }
+    if (currentLine)
+        lines.push(currentLine);
+    return lines.length > 0 ? lines : [''];
+}
+//# sourceMappingURL=text-wrapper.js.map

package/dist/presentation/dev-ui.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Presentation utilities for dev command.
+ * Separates UI/logic concerns by providing functions for displaying messages.
+ */
+/**
+ * Build initial welcome messages for dev mode.
+ * Returns empty array - welcome banner now handles all welcome info.
+ */
+export declare function buildDevWelcomeMessages(): Array<{
+    role: 'system';
+    content: string;
+}>;
+/**
+ * Format tools list for display.
+ */
+export declare function formatToolsList(tools: Array<{
+    name: string;
+    description?: string;
+}>): string;
+/**
+ * Format command history for display.
+ */
+export declare function formatCommandHistory(historyLines: string[]): string;
+/**
+ * Format tool call info for display.
+ */
+export declare function formatToolCallInfo(name: string, arguments_: unknown): string;
+/**
+ * Format tool result for display.
+ * Handles large JSON efficiently with size-based formatting.
+ */
+export declare function formatToolResult(name: string, result: unknown, duration?: number): string;
+//# sourceMappingURL=dev-ui.d.ts.map

package/dist/presentation/dev-ui.js

@@ -0,0 +1,246 @@
+/**
+ * Presentation utilities for dev command.
+ * Separates UI/logic concerns by providing functions for displaying messages.
+ */
+import { Messages } from '../constants/index.js';
+import { estimateObjectSize, formatJSONWithPagination, getJSONSummary, } from '../utils/json-formatter.js';
+/**
+ * Build initial welcome messages for dev mode.
+ * Returns empty array - welcome banner now handles all welcome info.
+ */
+export function buildDevWelcomeMessages() {
+    // Return empty array - welcome banner now handles all welcome info
+    // Old welcome messages are no longer needed as they're displayed in the persistent banner
+    return [];
+}
+/**
+ * Format tools list for display.
+ */
+export function formatToolsList(tools) {
+    let toolsList = `${Messages.DEV_TOOLS_HEADER}\n`;
+    if (tools.length === 0) {
+        toolsList += `${Messages.DEV_NO_TOOLS}`;
+    }
+    else {
+        for (const tool of tools) {
+            toolsList += `  • ${tool.name}`;
+            if (tool.description) {
+                toolsList += `: ${tool.description}`;
+            }
+            toolsList += '\n';
+        }
+    }
+    return toolsList.trim();
+}
+/**
+ * Format command history for display.
+ */
+export function formatCommandHistory(historyLines) {
+    if (historyLines.length === 0) {
+        return Messages.DEV_NO_HISTORY;
+    }
+    let historyList = `${Messages.DEV_HISTORY_HEADER}\n`;
+    historyLines.forEach((line, index) => {
+        historyList += `  ${index + 1}. ${line}\n`;
+    });
+    return historyList.trim();
+}
+/**
+ * Format tool call info for display.
+ */
+export function formatToolCallInfo(name, arguments_) {
+    return `${Messages.DEV_TOOL_CALLING(name)}\nArguments: ${JSON.stringify(arguments_, null, 2)}`;
+}
+/**
+ * Format tool result for display.
+ * Handles large JSON efficiently with size-based formatting.
+ */
+export function formatToolResult(name, result, duration) {
+    const completed = Messages.DEV_TOOL_COMPLETED(name, duration);
+    // Fast size estimation without full stringification for very large data
+    // Use a lightweight size check first
+    let sizeBytes;
+    let resultText;
+    let parsedData = result;
+    try {
+        // Try lightweight size estimation first
+        if (typeof result === 'string') {
+            resultText = result;
+            sizeBytes = Buffer.byteLength(result, 'utf8');
+            try {
+                parsedData = JSON.parse(result);
+            }
+            catch {
+                // Not JSON, treat as string
+                parsedData = result;
+            }
+        }
+        else {
+            // For objects, estimate size without full stringification
+            // This is much faster for large objects
+            // Create a small sample by taking a slice/portion of the data
+            let sample;
+            if (Array.isArray(result)) {
+                // Sample first 10 items
+                sample = result.slice(0, 10);
+            }
+            else if (typeof result === 'object' &&
+                result !== null &&
+                !Array.isArray(result)) {
+                // Sample first 10 keys
+                const keys = Object.keys(result).slice(0, 10);
+                sample = Object.fromEntries(keys.map(key => [key, result[key]]));
+            }
+            else {
+                sample = result;
+            }
+            const sampleString = JSON.stringify(sample);
+            const estimatedSizePerChar = sampleString.length === 0
+                ? 1 // Default to 1 byte per char for empty string (UTF-8 average)
+                : Buffer.byteLength(sampleString, 'utf8') / sampleString.length;
+            const estimatedTotalChars = estimateObjectSize(result);
+            sizeBytes = Math.floor(estimatedTotalChars * estimatedSizePerChar);
+            // Only stringify if we need to (for small/medium sizes)
+            if (sizeBytes < 500 * 1024) {
+                resultText = JSON.stringify(result, null, 2);
+            }
+            else {
+                // For large data, skip stringification - we'll just show summary
+                resultText = '';
+            }
+        }
+    }
+    catch {
+        // Fallback: treat as string
+        resultText = String(result);
+        sizeBytes = Buffer.byteLength(resultText, 'utf8');
+        parsedData = result;
+    }
+    const sizeKB = sizeBytes / 1024;
+    const sizeMB = sizeKB / 1024;
+    const sizeDisplay = sizeMB >= 1 ? `${sizeMB.toFixed(2)}MB` : `${sizeKB.toFixed(2)}KB`;
+    // For very large JSON (> 500KB), skip all expensive operations
+    // Just show a simple summary to avoid blocking the UI
+    if (sizeBytes > 500 * 1024) {
+        // Very large: Skip all formatting, just show summary
+        let structureInfo = '';
+        try {
+            if (Array.isArray(parsedData)) {
+                structureInfo = `Array with ${parsedData.length} items`;
+            }
+            else if (typeof parsedData === 'object' &&
+                parsedData !== null &&
+                !Array.isArray(parsedData)) {
+                const keys = Object.keys(parsedData);
+                structureInfo = `Object with ${keys.length} keys: ${keys.slice(0, 10).join(', ')}${keys.length > 10 ? '...' : ''}`;
+            }
+        }
+        catch {
+            // Ignore errors in structure detection
+        }
+        return `${completed}\nResult (${sizeDisplay}${structureInfo ? ` | ${structureInfo}` : ''}):\n\n⚠️  Very large result - formatting skipped to maintain UI responsiveness.\n💡 Use /save-json to export the full data to a file for analysis.\n💡 Full JSON data is available in conversation history for LLM processing.`;
+    }
+    // For smaller data, we can do formatting (but still optimized)
+    // Get JSON summary for structure info (only for data we'll format)
+    let summary;
+    try {
+        summary = getJSONSummary(parsedData);
+    }
+    catch {
+        // If summary fails, use basic info
+        summary = {
+            type: Array.isArray(parsedData)
+                ? 'array'
+                : typeof parsedData === 'object' && parsedData !== null
+                    ? 'object'
+                    : typeof parsedData,
+            size: sizeBytes,
+            depth: 0,
+            hasLargeArrays: Array.isArray(parsedData) && parsedData.length > 100,
+        };
+    }
+    // Size-based formatting strategy (only for < 500KB)
+    // Show collapsed summary by default for better performance
+    if (sizeBytes < 100 * 1024) {
+        // Small JSON (< 100KB): Show collapsed summary with option to expand
+        try {
+            // Get a quick summary without full formatting
+            let summaryText = '';
+            if (Array.isArray(parsedData)) {
+                summaryText = `Array with ${parsedData.length} items`;
+                if (parsedData.length > 0) {
+                    summaryText += ` (showing first 3)`;
+                    const preview = parsedData.slice(0, 3);
+                    const previewStr = JSON.stringify(preview, null, 2).substring(0, 500);
+                    summaryText += `:\n${previewStr}${parsedData.length > 3 ? '\n... (use /save-json to see full data)' : ''}`;
+                }
+            }
+            else if (typeof parsedData === 'object' &&
+                parsedData !== null &&
+                !Array.isArray(parsedData)) {
+                const keys = Object.keys(parsedData);
+                summaryText = `Object with ${keys.length} keys`;
+                if (keys.length > 0) {
+                    summaryText += ` (showing first 5)`;
+                    const previewKeys = keys.slice(0, 5);
+                    const preview = Object.fromEntries(previewKeys.map(k => [
+                        k,
+                        parsedData[k],
+                    ]));
+                    const previewStr = JSON.stringify(preview, null, 2).substring(0, 500);
+                    summaryText += `:\n${previewStr}${keys.length > 5 ? '\n... (use /save-json to see full data)' : ''}`;
+                }
+            }
+            else {
+                // Primitive or small value: show directly
+                summaryText = JSON.stringify(parsedData, null, 2).substring(0, 1000);
+            }
+            return `${completed}\nResult (${sizeDisplay}):\n${summaryText}\n\n💡 Use /save-json to export the full data to a file.`;
+        }
+        catch {
+            // Fallback to plain JSON if formatting fails
+            const fallbackText = typeof parsedData === 'string'
+                ? parsedData.substring(0, 1000)
+                : JSON.stringify(parsedData, null, 2).substring(0, 1000);
+            return `${completed}\nResult (${sizeDisplay}):\n${fallbackText}${sizeBytes > 1000 ? '\n... (use /save-json to see full data)' : ''}`;
+        }
+    }
+    else {
+        // Medium JSON (100KB - 500KB): Show tree with pagination
+        try {
+            const treeFormatted = formatJSONWithPagination(parsedData, {
+                maxDepth: 3,
+                maxArrayItems: 50,
+                itemsPerPage: 20,
+                currentPage: 0,
+            });
+            let structureInfo = '';
+            if (summary.itemCount !== undefined) {
+                structureInfo = ` | ${summary.itemCount} items`;
+            }
+            else if (summary.keyCount !== undefined) {
+                structureInfo = ` | ${summary.keyCount} keys`;
+            }
+            return `${completed}\nResult (${sizeDisplay}${structureInfo}):\n${treeFormatted}\n\n💡 Tip: Large arrays are paginated. Use /save-json to export full data.`;
+        }
+        catch {
+            // Fallback to summary if tree formatting fails
+            if (!resultText) {
+                resultText = JSON.stringify(parsedData, null, 2).substring(0, 5000);
+            }
+            const lines = resultText.split('\n');
+            const previewLines = 30;
+            const preview = lines.slice(0, previewLines).join('\n');
+            const remaining = lines.length - previewLines;
+            let structureInfo = '';
+            if (summary.itemCount !== undefined) {
+                structureInfo = ` | ${summary.itemCount} items`;
+            }
+            else if (summary.keyCount !== undefined) {
+                structureInfo = ` | ${summary.keyCount} keys`;
+            }
+            return `${completed}\nResult (${sizeDisplay}${structureInfo}):\n\nPreview (first ${previewLines} lines, ${remaining} more):\n${preview}\n\n[... ${remaining} more lines ...]`;
+        }
+    }
+}
+//# sourceMappingURL=dev-ui.js.map

package/dist/presentation/doctor-ui.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Presentation layer for doctor command UI.
+ * Provides modern, minimalistic display for configuration validation results.
+ */
+interface CheckResult {
+    isValid: boolean;
+    message: string;
+    fix?: string;
+    value?: string;
+}
+interface DoctorReport {
+    config: {
+        version: unknown;
+        project_name: unknown;
+        agent_name: unknown;
+        transport: string;
+        mcp_url?: unknown;
+        script?: unknown;
+    };
+    transportCheck: CheckResult;
+    scriptCheck: CheckResult | null;
+    llmChecks: Array<{
+        provider: string;
+        apiKeyCheck: CheckResult;
+        modelCheck: CheckResult;
+        isDefault: boolean;
+    }>;
+    localLlmChecks?: Array<{
+        provider: string;
+        check: CheckResult;
+        modelName?: string;
+    }>;
+}
+/**
+ * Display doctor report using plain console output.
+ * This avoids Ink taking control of stdin, which disables terminal history.
+ */
+export declare function displayDoctorReport(report: DoctorReport): Promise<void>;
+export {};
+//# sourceMappingURL=doctor-ui.d.ts.map