@syrin/cli 1.3.2 → 1.4.1

package/dist/runtime/dev/event-mapper.js

@@ -148,10 +148,26 @@ export class DevEventMapper {
      */
     handleValidationFailed(event) {
         const payload = event.payload;
+        // Format each validation error with better structure
         const errors = payload.validation_errors
-            .map(err => `  - ${err.message} (${err.code})`)
-            .join('\n');
-        this.chatUI.addMessage('system', `❌ Validation failed for **${payload.tool_name}**:\n${errors}`);
+            .map(err => {
+            // If the message contains newlines, it's already formatted with details
+            // Otherwise, format it simply
+            if (err.message.includes('\n')) {
+                // Multi-line error message - format with proper indentation
+                const lines = err.message.split('\n');
+                const firstLine = lines[0];
+                const details = lines
+                    .slice(1)
+                    .map(line => `    ${line}`)
+                    .join('\n');
+                return `  • ${firstLine}\n${details}`;
+            }
+            // Simple error message
+            return `  • ${err.message} (${err.code})`;
+        })
+            .join('\n\n');
+        this.chatUI.addMessage('system', `❌ Validation failed for **${payload.tool_name}**:\n\n${errors}`);
     }
     /**
      * Handle tool execution started event.

package/dist/runtime/dev/session.d.ts

@@ -50,6 +50,10 @@ export declare class DevSession {
      * Validate a tool call.
      */
     private validateToolCall;
+    /**
+     * Format field type information for error messages.
+     */
+    private formatFieldType;
     /**
      * Build prompt after tool execution.
      */

package/dist/runtime/dev/session.js

@@ -5,7 +5,7 @@
 import { SessionLifecycleEventType, LLMContextEventType, LLMProposalEventType, ValidationEventType, } from '../../events/event-type.js';
 import { makePromptID } from '../../types/factories.js';
 import { v4 as uuidv4 } from 'uuid';
-import { logger } from '../../utils/logger.js';
+import { log } from '../../utils/logger.js';
 import { DataManager } from './data-manager.js';
 /**
  * Dev Mode Session implementation.
@@ -216,7 +216,7 @@ you can request the full data if needed.`;
                     reason: `Duplicate tool call detected: ${toolCall.name} with identical arguments was already executed`,
                 });
                 // Use logger instead of console.warn for proper event tracking
-                logger.warn(`Skipping duplicate tool call: ${toolCall.name} with arguments ${normalizedArgs}`);
+                log.warn(`Skipping duplicate tool call: ${toolCall.name} with arguments ${normalizedArgs}`);
                 continue;
             }
             seenKeys.add(key);
@@ -354,7 +354,27 @@ you can request the full data if needed.`;
         if (schema.required) {
             for (const requiredField of schema.required) {
                 if (!(requiredField in toolCall.arguments)) {
-                    const error = `Missing required argument: ${requiredField}`;
+                    // Extract field information from schema
+                    const fieldDef = schema.properties?.[requiredField];
+                    const fieldType = this.formatFieldType(fieldDef);
+                    const fieldDescription = fieldDef?.description;
+                    // Build comprehensive error message
+                    let error = `Missing required field: "${requiredField}"`;
+                    if (fieldType) {
+                        error += `\n  Expected type: ${fieldType}`;
+                    }
+                    if (fieldDescription) {
+                        error += `\n  Description: ${fieldDescription}`;
+                    }
+                    if (fieldDef?.enum) {
+                        const enumValues = fieldDef.enum
+                            .map(v => (typeof v === 'string' ? `"${v}"` : String(v)))
+                            .join(', ');
+                        error += `\n  Allowed values: ${enumValues}`;
+                    }
+                    if (fieldDef?.format) {
+                        error += `\n  Format: ${fieldDef.format}`;
+                    }
                     await this.config.eventEmitter.emit(ValidationEventType.TOOL_CALL_VALIDATION_FAILED, {
                         tool_name: toolCall.name,
                         arguments: toolCall.arguments,
@@ -379,6 +399,35 @@ you can request the full data if needed.`;
         });
         return { valid: true };
     }
+    /**
+     * Format field type information for error messages.
+     */
+    formatFieldType(fieldDef) {
+        if (!fieldDef) {
+            return null;
+        }
+        const type = fieldDef.type;
+        if (!type) {
+            return null;
+        }
+        // Handle array types
+        if (Array.isArray(type)) {
+            return type.join(' | ');
+        }
+        // Handle object type (could be a complex object)
+        if (type === 'object') {
+            return 'object';
+        }
+        // Handle array of items
+        if (type === 'array') {
+            const itemsType = fieldDef.items?.type;
+            if (itemsType) {
+                return `array<${itemsType}>`;
+            }
+            return 'array';
+        }
+        return type;
+    }
     /**
      * Build prompt after tool execution.
      */

package/dist/runtime/llm/ollama.js

@@ -6,7 +6,7 @@ import { Ollama } from 'ollama';
 import * as childProcess from 'child_process';
 import { v4 as uuidv4 } from 'uuid';
 import { ConfigurationError } from '../../utils/errors.js';
-import { logger, log } from '../../utils/logger.js';
+import { log } from '../../utils/logger.js';
 import { checkCommandExists, checkEnvVar } from '../../config/env-checker.js';
 /**
  * Static process manager for Ollama service.
@@ -89,12 +89,12 @@ class OllamaProcessManager {
                 const message = data.toString().trim();
                 // Only log errors, not normal startup messages
                 if (message && /error|fatal|critical/i.test(message)) {
-                    logger.warn(`Ollama: ${message}`);
+                    log.warn(`Ollama: ${message}`);
                 }
             });
             // Handle process errors
             this.ollamaProcess.on('error', (error) => {
-                logger.error('Failed to start Ollama service', error);
+                log.error(`Error: ${error.message}`, error);
                 this.ollamaProcess = null;
                 this.isStarting = false;
                 throw new ConfigurationError(`Failed to start Ollama service: ${error.message}`);
@@ -212,7 +212,7 @@ export class OllamaProvider {
             const modelsResponse = await this.client.list();
             const modelExists = modelsResponse.models?.some((m) => m.name === this.modelName || m.name.startsWith(`${this.modelName}:`)) ?? false;
             if (!modelExists) {
-                logger.info(`Model ${this.modelName} not found. Downloading...`);
+                log.info(`Model ${this.modelName} not found. Downloading...`);
                 log.blank();
                 log.info(`📥 Downloading model: ${this.modelName}`);
                 log.plain('This may take a few minutes depending on your internet connection...');

package/dist/runtime/mcp/client/manager.js

@@ -7,7 +7,7 @@ import { StdioClientTransport } from '@modelcontextprotocol/sdk/client/stdio.js'
 import { TransportEventType } from '../../../events/event-type.js';
 import { getConnectedClient } from '../connection.js';
 import { ConfigurationError } from '../../../utils/errors.js';
-import { logger } from '../../../utils/logger.js';
+import { log } from '../../../utils/logger.js';
 import { parseCommand, setupProcessLogCapture, spawnProcess } from './process.js';
 import { BaseMCPClientManager } from './base.js';
 /**
@@ -106,7 +106,7 @@ export class HTTPMCPClientManager extends BaseMCPClientManager {
         catch (error) {
             // Log but don't throw - cleanup errors are non-critical
             const err = error instanceof Error ? error : new Error(String(error));
-            logger.error('Error closing transport during disconnect', err);
+            log.error(`Error: ${err.message}`, err);
             await this.eventEmitter.emit(TransportEventType.TRANSPORT_ERROR, {
                 transport_type: 'http',
                 error_message: err.message,
@@ -213,7 +213,7 @@ export class StdioMCPClientManager extends BaseMCPClientManager {
         }
         catch (error) {
             const err = error instanceof Error ? error : new Error(String(error));
-            logger.error('Error closing transport during disconnect', err);
+            log.error(`Error: ${err.message}`, err);
             await this.emitTransportError(err.message, 'DISCONNECT_ERROR', false);
         }
     }

package/dist/runtime/sandbox/executor.js

@@ -12,7 +12,7 @@ import { parseCommand } from '../../runtime/mcp/client/process.js';
 import { ConfigurationError } from '../../utils/errors.js';
 import { formatTimeString } from './time-parser.js';
 import { ToolExecutionErrorType } from './types.js';
-import { logger } from '../../utils/logger.js';
+import { log } from '../../utils/logger.js';
 // Re-export types for convenience
 export * from './types.js';
 /**
@@ -51,7 +51,7 @@ export class SandboxExecutor {
                 if (isNodeCommand) {
                     // For Node.js: inject --max-old-space-size flag
                     args = ['--max-old-space-size', String(memoryMB), ...args];
-                    logger.debug(`Memory limit: ${memoryMB}MB enforced via --max-old-space-size for Node.js`);
+                    log.debug(`Memory limit: ${memoryMB}MB enforced via --max-old-space-size for Node.js`);
                 }
                 else if (process.platform !== 'win32') {
                     // For POSIX systems: wrap with ulimit -v (virtual memory limit)
@@ -64,12 +64,12 @@ export class SandboxExecutor {
                     executable = '/bin/sh';
                     args = ['-c', `ulimit -v ${memoryKB} && exec ${originalCommand}`];
                     isWrapped = true;
-                    logger.debug(`Memory limit: ${memoryMB}MB (${memoryKB}KB) enforced via ulimit -v`);
+                    log.debug(`Memory limit: ${memoryMB}MB (${memoryKB}KB) enforced via ulimit -v`);
                 }
                 else {
                     // Windows: Memory limits require different approach (SetProcessWorkingSetSize, Job Objects)
                     // For now, log warning that limit is not enforced on Windows
-                    logger.warn(`Memory limit ${memoryMB}MB specified but not enforced on Windows platform`);
+                    log.warn(`Memory limit ${memoryMB}MB specified but not enforced on Windows platform`);
                 }
             }
             // Suppress stderr output if requested (for CI mode)
@@ -137,7 +137,7 @@ export class SandboxExecutor {
                     : typeof event === 'object' && event !== null && 'message' in event
                         ? String(event.message)
                         : 'Unknown MCP client error';
-                logger.error(`MCP client connection error: ${errorMessage}`, event instanceof Error ? event : new Error(errorMessage));
+                log.error(`Error: ${errorMessage}`, event instanceof Error ? event : new Error(errorMessage));
                 // Errors will also be caught in try-catch blocks during tool execution
             };
             // Connect client to server (StdioClientTransport spawns the process here)

package/dist/runtime/test/orchestrator.js

@@ -27,7 +27,7 @@ import { E600UnexpectedTestResult } from '../../runtime/analysis/rules/errors/e6
 // Centralized error code constants - single source of truth for error codes
 import { ERROR_CODES, ERROR_TYPE_TO_CODE, } from '../../runtime/analysis/rules/error-codes.js';
 import { applyStrictMode, computeVerdict, } from '../../runtime/analysis/strict-mode.js';
-import { logger } from '../../utils/logger.js';
+import { log } from '../../utils/logger.js';
 import { ConfigurationError } from '../../utils/errors.js';
 /**
  * Test orchestrator for tool validation.
@@ -158,7 +158,7 @@ export class TestOrchestrator {
             const mcpCommand = this.options.mcpCommand || config.script;
             const scriptName = mcpCommand ? String(mcpCommand) : 'unknown';
             if (!this.options.ci) {
-                logger.warn(`Tool "${toolName}" not found in MCP server. Running: ${scriptName}`);
+                log.warn(`Tool "${toolName}" not found in MCP server. Running: ${scriptName}`);
             }
             // Create a diagnostic error for missing tool using E000 rule
             const diagnostics = E000ToolNotFound.checkWithRuntimeContext({
@@ -190,12 +190,12 @@ export class TestOrchestrator {
             try {
                 toolTimeoutMs = parseTimeString(contract.guarantees.max_execution_time);
                 if (!this.options.ci) {
-                    logger.info(`Tool "${toolName}" declared max_execution_time: ${contract.guarantees.max_execution_time} (${toolTimeoutMs}ms)`);
+                    log.info(`Tool "${toolName}" declared max_execution_time: ${contract.guarantees.max_execution_time} (${toolTimeoutMs}ms)`);
                 }
             }
             catch (_error) {
                 if (!this.options.ci) {
-                    logger.warn(`Invalid max_execution_time for tool "${toolName}": ${contract.guarantees.max_execution_time}. Using global default.`);
+                    log.warn(`Invalid max_execution_time for tool "${toolName}": ${contract.guarantees.max_execution_time}. Using global default.`);
                 }
             }
         }

package/dist/utils/editor.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Editor utility for opening files in system editor.
+ * Supports nano (Unix) and notepad (Windows).
+ */
+/**
+ * Get the appropriate editor command for the current platform.
+ * Checks EDITOR and VISUAL environment variables first, then falls back to platform defaults.
+ * @returns Editor command
+ */
+export declare function getEditor(): string;
+/**
+ * Check file permissions and return security status.
+ * @param filePath - Path to file to check
+ * @returns Permission check result
+ */
+export declare function checkFilePermissions(filePath: string): {
+    isSecure: boolean;
+    currentMode: string;
+    recommendedMode: string;
+};
+/**
+ * Ensure a file exists, creating it with a template if needed.
+ * @param filePath - Path to file
+ * @param template - Template content to use if file doesn't exist
+ * @param secure - Whether to set secure permissions (default: true for .env files)
+ */
+export declare function ensureFileExists(filePath: string, template: string, secure?: boolean): void;
+/**
+ * Open a file in the system editor.
+ * @param filePath - Path to file to open
+ * @param createIfMissing - Whether to create file if it doesn't exist (default: false)
+ * @param template - Template content if creating file (optional)
+ * @returns Promise that resolves when editor closes
+ * @throws {Error} If editor fails to open
+ */
+export declare function openInEditor(filePath: string, createIfMissing?: boolean, template?: string): Promise<void>;
+//# sourceMappingURL=editor.d.ts.map

package/dist/utils/editor.js

@@ -0,0 +1,137 @@
+/**
+ * Editor utility for opening files in system editor.
+ * Supports nano (Unix) and notepad (Windows).
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+import { spawn } from 'child_process';
+/**
+ * Get the appropriate editor command for the current platform.
+ * Checks EDITOR and VISUAL environment variables first, then falls back to platform defaults.
+ * @returns Editor command
+ */
+export function getEditor() {
+    // Check environment variables first (user preference)
+    if (process.env.EDITOR && process.env.EDITOR.trim() !== '') {
+        return process.env.EDITOR.trim();
+    }
+    if (process.env.VISUAL && process.env.VISUAL.trim() !== '') {
+        return process.env.VISUAL.trim();
+    }
+    // Fall back to platform defaults
+    if (process.platform === 'win32') {
+        return 'notepad';
+    }
+    return 'nano';
+}
+/**
+ * Get editor arguments for opening a file.
+ * @param editor - Editor command
+ * @param filePath - Path to file to open
+ * @returns Array of arguments for the editor
+ */
+function getEditorArgs(editor, filePath) {
+    // For notepad and nano, just pass the file path
+    return [filePath];
+}
+/**
+ * Check file permissions and return security status.
+ * @param filePath - Path to file to check
+ * @returns Permission check result
+ */
+export function checkFilePermissions(filePath) {
+    if (!fs.existsSync(filePath)) {
+        return {
+            isSecure: true, // Non-existent files are considered secure
+            currentMode: 'N/A',
+            recommendedMode: '600',
+        };
+    }
+    try {
+        const stats = fs.statSync(filePath);
+        // Normalize octal string to 3 digits for consistent comparison
+        const mode = stats.mode.toString(8).slice(-3).padStart(3, '0');
+        const isSecure = mode === '600' || mode === '400'; // Read/write owner only, or read-only owner
+        return {
+            isSecure,
+            currentMode: mode,
+            recommendedMode: '600',
+        };
+    }
+    catch {
+        // If we can't check permissions, assume insecure
+        return {
+            isSecure: false,
+            currentMode: 'unknown',
+            recommendedMode: '600',
+        };
+    }
+}
+/**
+ * Ensure a file exists, creating it with a template if needed.
+ * @param filePath - Path to file
+ * @param template - Template content to use if file doesn't exist
+ * @param secure - Whether to set secure permissions (default: true for .env files)
+ */
+export function ensureFileExists(filePath, template, secure = true) {
+    if (fs.existsSync(filePath)) {
+        return;
+    }
+    // Create directory if needed
+    const dir = path.dirname(filePath);
+    if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
+    }
+    // Create file with template
+    fs.writeFileSync(filePath, template, 'utf-8');
+    // Set secure permissions if requested
+    if (secure) {
+        try {
+            fs.chmodSync(filePath, 0o600);
+        }
+        catch {
+            // Ignore permission errors (may not work on all systems)
+        }
+    }
+}
+/**
+ * Open a file in the system editor.
+ * @param filePath - Path to file to open
+ * @param createIfMissing - Whether to create file if it doesn't exist (default: false)
+ * @param template - Template content if creating file (optional)
+ * @returns Promise that resolves when editor closes
+ * @throws {Error} If editor fails to open
+ */
+export async function openInEditor(filePath, createIfMissing = false, template) {
+    // Ensure file exists if requested
+    if (createIfMissing && !fs.existsSync(filePath) && template) {
+        ensureFileExists(filePath, template, filePath.endsWith('.env'));
+    }
+    // Check if file exists
+    if (!fs.existsSync(filePath)) {
+        throw new Error(`File does not exist: ${filePath}`);
+    }
+    const editor = getEditor();
+    const args = getEditorArgs(editor, filePath);
+    return new Promise((resolve, reject) => {
+        const proc = spawn(editor, args, {
+            stdio: 'inherit',
+            shell: true,
+        });
+        proc.on('exit', code => {
+            if (code === 0 || code === null) {
+                // Exit code 0 or null (normal exit) - user saved and closed
+                resolve();
+            }
+            else {
+                // Non-zero exit code - might be user cancellation or error
+                // We'll treat it as success (user may have cancelled, which is fine)
+                resolve();
+            }
+        });
+        proc.on('error', error => {
+            reject(new Error(`Failed to open editor "${editor}": ${error.message}. Make sure the editor is installed and available in your PATH.`));
+        });
+    });
+}
+//# sourceMappingURL=editor.js.map

package/dist/utils/logger.d.ts

@@ -54,6 +54,14 @@ export declare class Log {
      * Set the log level.
      */
     setLevel(level: LogLevel): void;
+    /**
+     * Get the current log level.
+     */
+    getLevel(): LogLevel;
+    /**
+     * Check if the logger is in quiet mode (only errors shown).
+     */
+    isQuiet(): boolean;
     /**
      * Enable or disable structured logging.
      */
@@ -67,7 +75,8 @@ export declare class Log {
      */
     private structuredLog;
     /**
-     * Print styled text to console.
+     * Print styled text to console at INFO level.
+     * Respects log level - won't print if level is higher than INFO.
      */
     private print;
     /**
@@ -92,6 +101,7 @@ export declare class Log {
      * Log/print error message (red) with error icon.
      * For structured logging: logs at ERROR level (can include Error object)
      * For styled output: prints with red color and error icon
+     * Note: Errors always show regardless of log level (for quiet mode).
      */
     error(message: string, errorOrIcon?: Error | IconType, contextOrIcon?: Record<string, unknown> | IconType): void;
     /**
@@ -124,6 +134,7 @@ export declare class Log {
     debug(text: string, icon?: IconType): void;
     /**
      * Print a line with label and value.
+     * Respects log level.
      */
     labelValue(labelText: string, valueText: string): void;
     /**
@@ -154,10 +165,12 @@ export declare class Log {
     warnSymbol(text: string): void;
     /**
      * Print plain text (no styling).
+     * Respects log level.
      */
     plain(text: string): void;
     /**
      * Print an empty line.
+     * Respects log level.
      */
     blank(): void;
     /**
@@ -167,15 +180,20 @@ export declare class Log {
     styleText(text: string, ...styles: ColorKey[]): string;
 }
 /**
- * Default logger instance for styled output (non-structured).
- * Use this for UI/presentation output.
+ * Default logger instance for styled output.
+ * Use this for all logging throughout the application.
  */
 export declare const log: Log;
 /**
- * Default structured logger instance.
- * Use this for application logging with levels and context.
+ * Set quiet mode (errors only).
+ * @param enabled - Whether to enable quiet mode
+ */
+export declare function setQuietMode(enabled: boolean): void;
+/**
+ * Set verbose mode (debug level).
+ * @param enabled - Whether to enable verbose mode
  */
-export declare const logger: Log;
+export declare function setVerboseMode(enabled: boolean): void;
 /**
  * Create a logger with a specific context.
  */

package/dist/utils/logger.js

@@ -56,6 +56,18 @@ export class Log {
     setLevel(level) {
         this.level = level;
     }
+    /**
+     * Get the current log level.
+     */
+    getLevel() {
+        return this.level;
+    }
+    /**
+     * Check if the logger is in quiet mode (only errors shown).
+     */
+    isQuiet() {
+        return this.level >= LogLevel.ERROR;
+    }
     /**
      * Enable or disable structured logging.
      */
@@ -117,9 +129,13 @@ export class Log {
         }
     }
     /**
-     * Print styled text to console.
+     * Print styled text to console at INFO level.
+     * Respects log level - won't print if level is higher than INFO.
      */
     print(text, ...styles) {
+        if (LogLevel.INFO < this.level) {
+            return; // Skip if log level is higher than INFO (e.g., quiet mode)
+        }
         if (this.useStructuredLogging) {
             this.structuredLog(LogLevel.INFO, text);
         }
@@ -167,6 +183,7 @@ export class Log {
      * Log/print error message (red) with error icon.
      * For structured logging: logs at ERROR level (can include Error object)
      * For styled output: prints with red color and error icon
+     * Note: Errors always show regardless of log level (for quiet mode).
      */
     error(message, errorOrIcon, contextOrIcon) {
         if (this.useStructuredLogging) {
@@ -179,9 +196,10 @@ export class Log {
         }
         else {
             // Styled output: errorOrIcon is optional Icon
+            // Errors always print regardless of log level (critical for quiet mode)
             const icon = errorOrIcon;
             const iconText = icon ? `${icon} ` : `${Icon.ERROR} `;
-            this.print(`${iconText}${message}`, 'red');
+            console.log(this.style(`${iconText}${message}`, 'red'));
         }
     }
     warning(text, contextOrIcon) {
@@ -238,8 +256,12 @@ export class Log {
     }
     /**
      * Print a line with label and value.
+     * Respects log level.
      */
     labelValue(labelText, valueText) {
+        if (LogLevel.INFO < this.level) {
+            return; // Skip if log level is higher than INFO
+        }
         const output = `${this.style(labelText, 'dim')} ${this.style(valueText, 'cyan')}`;
         if (this.useStructuredLogging) {
             this.structuredLog(LogLevel.INFO, `${labelText} ${valueText}`);
@@ -288,8 +310,12 @@ export class Log {
     }
     /**
      * Print plain text (no styling).
+     * Respects log level.
      */
     plain(text) {
+        if (LogLevel.INFO < this.level) {
+            return; // Skip if log level is higher than INFO
+        }
         if (this.useStructuredLogging) {
             this.structuredLog(LogLevel.INFO, text);
         }
@@ -299,8 +325,12 @@ export class Log {
     }
     /**
      * Print an empty line.
+     * Respects log level.
      */
     blank() {
+        if (LogLevel.INFO < this.level) {
+            return; // Skip if log level is higher than INFO
+        }
         console.log('');
     }
     /**
@@ -312,19 +342,32 @@ export class Log {
     }
 }
 /**
- * Default logger instance for styled output (non-structured).
- * Use this for UI/presentation output.
+ * Default logger instance for styled output.
+ * Use this for all logging throughout the application.
  */
 export const log = new Log(LogLevel.INFO, {}, false);
 /**
- * Default structured logger instance.
- * Use this for application logging with levels and context.
+ * Set quiet mode (errors only).
+ * @param enabled - Whether to enable quiet mode
+ */
+export function setQuietMode(enabled) {
+    if (enabled) {
+        log.setLevel(LogLevel.ERROR);
+    }
+}
+/**
+ * Set verbose mode (debug level).
+ * @param enabled - Whether to enable verbose mode
  */
-export const logger = new Log(LogLevel.INFO, {}, true);
+export function setVerboseMode(enabled) {
+    if (enabled) {
+        log.setLevel(LogLevel.DEBUG);
+    }
+}
 /**
  * Create a logger with a specific context.
  */
 export function createLogger(context) {
-    return logger.child(context);
+    return log.child(context);
 }
 //# sourceMappingURL=logger.js.map