@syrin/cli 1.3.0

package/dist/presentation/doctor-ui.js

@@ -0,0 +1,157 @@
+import { getVersionDisplayString } from '../utils/version-display.js';
+import { log } from '../utils/logger.js';
+/**
+ * Display doctor report using plain console output.
+ * This avoids Ink taking control of stdin, which disables terminal history.
+ */
+export async function displayDoctorReport(report) {
+    const { config, transportCheck, scriptCheck, llmChecks, localLlmChecks } = report;
+    const allValid = transportCheck.isValid &&
+        (scriptCheck === null || scriptCheck.isValid) &&
+        llmChecks.every(l => l.apiKeyCheck.isValid && l.modelCheck.isValid) &&
+        (localLlmChecks === undefined ||
+            localLlmChecks.every(l => l.check.isValid));
+    // Get version info for display
+    const versionDisplayString = await getVersionDisplayString();
+    // Header
+    log.blank();
+    log.heading('Syrin Doctor Report');
+    log.label('═══════════════════');
+    log.labelValue('Version:', versionDisplayString);
+    log.blank();
+    // Project Info
+    log.labelValue('Project:', String(config.project_name));
+    log.labelValue('Agent:', String(config.agent_name));
+    log.blank();
+    // Transport Section
+    log.heading('Transport');
+    log.labelValue('  Type:', config.transport);
+    if (config.transport === 'http') {
+        const urlValue = config.mcp_url !== undefined && config.mcp_url !== null
+            ? config.mcp_url
+            : null;
+        const urlText = urlValue ? `URL: ${urlValue}` : 'URL: Not configured';
+        if (transportCheck.isValid) {
+            log.plain(`  ${urlText} ${log.tick()}`);
+        }
+        else {
+            log.plain(`  ${urlText} ${log.cross()}`);
+        }
+    }
+    else {
+        const scriptValue = config.script !== undefined && config.script !== null
+            ? config.script
+            : null;
+        const scriptText = scriptValue
+            ? `Script: ${scriptValue}`
+            : 'Script: Not configured';
+        if (transportCheck.isValid) {
+            log.plain(`  ${scriptText} ${log.tick()}`);
+        }
+        else {
+            log.plain(`  ${scriptText} ${log.cross()}`);
+        }
+    }
+    if (!transportCheck.isValid && transportCheck.fix) {
+        log.warnSymbol(`    ${transportCheck.fix}`);
+    }
+    log.blank();
+    // Script Section (if present)
+    if (scriptCheck !== null && config.script) {
+        const scriptText = String(config.script);
+        log.heading('Script');
+        if (scriptCheck.isValid) {
+            log.plain(`  ${scriptText} ${log.tick()}`);
+        }
+        else {
+            log.plain(`  ${scriptText} ${log.cross()}`);
+        }
+        if (!scriptCheck.isValid && scriptCheck.fix) {
+            log.warnSymbol(`    ${scriptCheck.fix}`);
+        }
+        log.blank();
+    }
+    /**
+     * Mask API key to show only first few characters.
+     */
+    function maskApiKey(apiKey) {
+        if (!apiKey)
+            return '';
+        if (apiKey.length <= 4)
+            return '****';
+        return `${apiKey.substring(0, 4)}*****`;
+    }
+    // LLM Providers Section
+    if (llmChecks.length > 0) {
+        log.heading('LLM Providers');
+        for (const llm of llmChecks) {
+            const providerName = llm.provider.charAt(0).toUpperCase() + llm.provider.slice(1);
+            const defaultMark = llm.isDefault
+                ? log.styleText(' (default)', 'cyan')
+                : '';
+            log.plain(`  ${log.styleText(providerName, 'bold')}${defaultMark}`);
+            // API Key
+            const apiKeyValue = llm.apiKeyCheck.value
+                ? ` (${maskApiKey(llm.apiKeyCheck.value)})`
+                : '';
+            const apiKeyLabel = `    API Key: [${llm.apiKeyCheck.message}]${apiKeyValue}`;
+            if (llm.apiKeyCheck.isValid) {
+                log.plain(`${apiKeyLabel} ${log.tick()}`);
+            }
+            else {
+                log.plain(`${apiKeyLabel} ${log.cross()}`);
+            }
+            if (!llm.apiKeyCheck.isValid && llm.apiKeyCheck.fix) {
+                log.warnSymbol(`      ${llm.apiKeyCheck.fix}`);
+            }
+            // Model
+            const modelValue = llm.modelCheck.value
+                ? ` (${llm.modelCheck.value})`
+                : '';
+            const modelLabel = `    Model: [${llm.modelCheck.message}]${modelValue}`;
+            if (llm.modelCheck.isValid) {
+                log.plain(`${modelLabel} ${log.tick()}`);
+            }
+            else {
+                log.plain(`${modelLabel} ${log.cross()}`);
+            }
+            if (!llm.modelCheck.isValid && llm.modelCheck.fix) {
+                log.warnSymbol(`      ${llm.modelCheck.fix}`);
+            }
+        }
+        log.blank();
+    }
+    // Local LLM Providers
+    if (localLlmChecks && localLlmChecks.length > 0) {
+        log.heading('Local LLM Providers');
+        for (const llm of localLlmChecks) {
+            log.plain(`  ${llm.provider}`);
+            if (llm.modelName) {
+                const modelLabel = `    Model: ${llm.modelName}`;
+                if (llm.check.isValid) {
+                    log.plain(`${modelLabel} ${log.tick()}`);
+                }
+                else {
+                    log.plain(`${modelLabel} ${log.cross()}`);
+                }
+            }
+            else if (llm.check.isValid) {
+                log.plain(`    ${log.tick()}`);
+            }
+            else {
+                log.plain(`    ${log.cross()}`);
+            }
+        }
+        log.blank();
+    }
+    // Summary
+    if (allValid) {
+        log.success('All checks passed');
+        log.blank();
+    }
+    else {
+        log.warning('Some issues found');
+        log.blank();
+    }
+}
+//# sourceMappingURL=doctor-ui.js.map

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

@@ -0,0 +1,14 @@
+/**
+ * Presentation utilities for init command.
+ * Separates UI/logic concerns by providing functions for displaying messages.
+ */
+/**
+ * Display the "already initialized" message.
+ */
+export declare function displayAlreadyInitialized(): void;
+/**
+ * Display the initialization success message.
+ * @param configPath - Path to the created config file
+ */
+export declare function displayInitSuccess(configPath: string): void;
+//# sourceMappingURL=init-ui.d.ts.map

package/dist/presentation/init-ui.js

@@ -0,0 +1,41 @@
+/**
+ * Presentation utilities for init command.
+ * Separates UI/logic concerns by providing functions for displaying messages.
+ */
+import { Icons, Messages, Paths, ToolCommands } from '../constants/index.js';
+import { log } from '../utils/logger.js';
+/**
+ * Display the "already initialized" message.
+ */
+export function displayAlreadyInitialized() {
+    log.blank();
+    log.warning(`  ${Messages.INIT_ALREADY_INITIALIZED}`);
+    log.blank();
+    log.plain(`${Icons.FOLDER} ${Messages.INIT_CONFIG_FILE(Paths.CONFIG_PATH)}`);
+    log.blank();
+    log.plain(`${Icons.DOCUMENT} ${Messages.INIT_NEXT_STEPS_HEADER}`);
+    log.plain(`   ${Messages.INIT_ALREADY_INIT_MSG(Paths.CONFIG_PATH)}`);
+    log.plain(`   ${Messages.INIT_VERIFY_SETUP(ToolCommands.DOCTOR)}`);
+    log.blank();
+    log.info(Messages.INIT_REINITIALIZE_TIP);
+    log.plain(`   ${Messages.INIT_REINITIALIZE_INSTRUCTION(ToolCommands.INIT)}`);
+    log.blank();
+}
+/**
+ * Display the initialization success message.
+ * @param configPath - Path to the created config file
+ */
+export function displayInitSuccess(configPath) {
+    log.blank();
+    log.success(`${Icons.CHECK} ${Messages.INIT_SUCCESS}`);
+    log.blank();
+    log.plain(`${Icons.FOLDER} Configuration file: ${configPath}`);
+    log.blank();
+    log.plain(`${Icons.DOCUMENT} ${Messages.INIT_NEXT_STEPS_HEADER}`);
+    log.plain(`   1. ${Messages.INIT_REVIEW_CONFIG(Paths.CONFIG_PATH)}`);
+    log.plain(`   2. ${Messages.INIT_SETUP_ENV_VARS}`);
+    log.plain(`   3. ${Messages.INIT_RUN_DOCTOR(ToolCommands.DOCTOR)}`);
+    log.plain(`   4. ${Messages.INIT_RUN_DEV(ToolCommands.DEV)}`);
+    log.blank();
+}
+//# sourceMappingURL=init-ui.js.map

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

@@ -0,0 +1,44 @@
+/**
+ * Presentation layer for list command UI components.
+ * Provides minimalistic, easy-to-read displays for tools, resources, and prompts.
+ */
+interface ToolInfo {
+    name: string;
+    title?: string;
+    description?: string;
+    inputSchema?: unknown;
+    outputSchema?: unknown;
+}
+interface ResourceInfo {
+    uri: string;
+    name?: string;
+    description?: string;
+    mimeType?: string;
+}
+interface PromptInfo {
+    name: string;
+    title?: string;
+    description?: string;
+    arguments?: Array<{
+        name: string;
+        description?: string;
+        required?: boolean;
+    }>;
+}
+/**
+ * Display tools list using plain console output.
+ * This avoids Ink taking control of stdin, which disables terminal history.
+ */
+export declare function displayTools(tools: ToolInfo[]): Promise<void>;
+/**
+ * Display resources list using plain console output.
+ * This avoids Ink taking control of stdin, which disables terminal history.
+ */
+export declare function displayResources(resources: ResourceInfo[]): Promise<void>;
+/**
+ * Display prompts list using plain console output.
+ * This avoids Ink taking control of stdin, which disables terminal history.
+ */
+export declare function displayPrompts(prompts: PromptInfo[]): Promise<void>;
+export {};
+//# sourceMappingURL=list-ui.d.ts.map

package/dist/presentation/list-ui.js

@@ -0,0 +1,139 @@
+import { getVersionDisplayString } from '../utils/version-display.js';
+import { log } from '../utils/logger.js';
+/**
+ * Extract and format parameter information from a JSON schema.
+ */
+function extractParameters(schema) {
+    if (!schema || typeof schema !== 'object') {
+        return [];
+    }
+    const schemaObj = schema;
+    if (!schemaObj.properties) {
+        return [];
+    }
+    const required = new Set(schemaObj.required || []);
+    const params = [];
+    for (const [name, prop] of Object.entries(schemaObj.properties)) {
+        const propObj = prop;
+        const type = propObj.type || 'unknown';
+        params.push({
+            name,
+            type,
+            required: required.has(name),
+        });
+    }
+    return params;
+}
+/**
+ * Display tools list using plain console output.
+ * This avoids Ink taking control of stdin, which disables terminal history.
+ */
+export async function displayTools(tools) {
+    // Get version info for display
+    const versionDisplayString = await getVersionDisplayString();
+    log.blank();
+    log.label(`Syrin ${versionDisplayString}`);
+    log.blank();
+    log.heading(`Tools: ${tools.length} ${tools.length === 1 ? 'tool' : 'tools'}`);
+    log.blank();
+    if (tools.length === 0) {
+        log.label('  No tools available');
+        log.blank();
+        return;
+    }
+    tools.forEach((tool, index) => {
+        const inputParams = extractParameters(tool.inputSchema);
+        const outputParams = extractParameters(tool.outputSchema);
+        log.numberedItem(index + 1, tool.name);
+        // Description
+        if (tool.description) {
+            log.label(`    ${tool.description.split('\n')[0]}`);
+        }
+        // Input parameters summary
+        if (inputParams.length > 0) {
+            log.label('    Parameters:');
+            for (const param of inputParams) {
+                const requiredText = param.required ? ' (required)' : '';
+                log.plain(`      • ${log.styleText(param.name, 'cyan')} ${log.styleText(`(${param.type})`, 'dim')}${requiredText ? log.styleText(requiredText, 'yellow') : ''}`);
+            }
+        }
+        else {
+            log.label('    No parameters');
+        }
+        // Output summary
+        if (outputParams.length > 0) {
+            log.plain(`    ${log.styleText('Returns:', 'dim')} ${log.styleText(String(outputParams.length), 'cyan')} ${log.styleText(outputParams.length === 1 ? 'property' : 'properties', 'dim')}`);
+        }
+        log.blank();
+    });
+}
+/**
+ * Display resources list using plain console output.
+ * This avoids Ink taking control of stdin, which disables terminal history.
+ */
+export async function displayResources(resources) {
+    // Get version info for display
+    const versionDisplayString = await getVersionDisplayString();
+    log.blank();
+    log.label(`Syrin ${versionDisplayString}`);
+    log.blank();
+    log.heading(`Resources: ${resources.length} ${resources.length === 1 ? 'resource' : 'resources'}`);
+    log.blank();
+    if (resources.length === 0) {
+        log.label('  No resources available');
+        log.blank();
+        return;
+    }
+    resources.forEach((resource, index) => {
+        log.numberedItem(index + 1, resource.uri);
+        if (resource.name) {
+            log.labelValue('    Name:', resource.name);
+        }
+        if (resource.description) {
+            log.label(`    ${resource.description.split('\n')[0]}`);
+        }
+        if (resource.mimeType) {
+            log.labelValue('    Type:', resource.mimeType);
+        }
+        log.blank();
+    });
+}
+/**
+ * Display prompts list using plain console output.
+ * This avoids Ink taking control of stdin, which disables terminal history.
+ */
+export async function displayPrompts(prompts) {
+    // Get version info for display
+    const versionDisplayString = await getVersionDisplayString();
+    log.blank();
+    log.label(`Syrin ${versionDisplayString}`);
+    log.blank();
+    log.heading(`Prompts: ${prompts.length} ${prompts.length === 1 ? 'prompt' : 'prompts'}`);
+    log.blank();
+    if (prompts.length === 0) {
+        log.label('  No prompts available');
+        log.blank();
+        return;
+    }
+    prompts.forEach((prompt, index) => {
+        log.numberedItem(index + 1, prompt.name);
+        if (prompt.description) {
+            log.label(`    ${prompt.description.split('\n')[0]}`);
+        }
+        if (prompt.arguments && prompt.arguments.length > 0) {
+            log.label('    Arguments:');
+            for (const arg of prompt.arguments) {
+                const requiredText = arg.required ? ' (required)' : '';
+                log.plain(`      • ${log.styleText(arg.name, 'cyan')}${requiredText ? log.styleText(requiredText, 'yellow') : ''}`);
+                if (arg.description) {
+                    log.label(`        ${arg.description.split('\n')[0]}`);
+                }
+            }
+        }
+        else {
+            log.label('    No arguments');
+        }
+        log.blank();
+    });
+}
+//# sourceMappingURL=list-ui.js.map

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

@@ -0,0 +1,49 @@
+/**
+ * Test Results UI for MCP Connection Testing and Tool Validation.
+ * Provides a minimalistic, easy-to-read display of connection test results
+ * and tool validation results.
+ */
+import type { MCPConnectionResult } from '../runtime/mcp/types.js';
+import type { TransportType } from '../config/types.js';
+import type { TestOrchestratorResult } from '../runtime/test/orchestrator.js';
+/**
+ * Context information for tool errors.
+ */
+export interface ToolErrorContext {
+    testName?: string;
+    testInput?: Record<string, unknown>;
+    expectedOutputSchema?: string;
+    parsedError?: {
+        field?: string;
+        message?: string;
+        inputValue?: string;
+        inputType?: string;
+        errorType?: string;
+    };
+}
+export interface TestResultsUIOptions {
+    /** Connection test result to display */
+    result: MCPConnectionResult;
+    /** Transport type being tested */
+    transport: TransportType;
+    /** Whether to show verbose details (HTTP request/response) */
+    verbose?: boolean;
+}
+/**
+ * Display test results using plain console output.
+ * This avoids Ink taking control of stdin, which disables terminal history.
+ */
+export declare function displayTestResults(options: TestResultsUIOptions): Promise<void>;
+/**
+ * Format test results for CI output (minimal).
+ */
+export declare function formatCIResults(result: TestOrchestratorResult): void;
+/**
+ * Format test results for CLI output.
+ */
+export declare function formatCLIResults(result: TestOrchestratorResult): void;
+/**
+ * Format test results as JSON.
+ */
+export declare function formatJSONResults(result: TestOrchestratorResult): string;
+//# sourceMappingURL=test-ui.d.ts.map