@cyanheads/git-mcp-server 2.0.2 → 2.0.4

package/dist/mcp-server/transports/stdioTransport.js

@@ -0,0 +1,87 @@
+/**
+ * Handles the setup and connection for the Stdio MCP transport.
+ * Implements the MCP Specification 2025-03-26 for stdio transport.
+ * This transport communicates directly over standard input (stdin) and
+ * standard output (stdout), typically used when the MCP server is launched
+ * as a child process by a host application.
+ *
+ * Specification Reference:
+ * https://github.com/modelcontextprotocol/modelcontextprotocol/blob/main/docs/specification/2025-03-26/basic/transports.mdx#stdio
+ *
+ * --- Authentication Note ---
+ * As per the MCP Authorization Specification (2025-03-26, Section 1.2),
+ * STDIO transports SHOULD NOT implement HTTP-based authentication flows.
+ * Authorization is typically handled implicitly by the host application
+ * controlling the server process. This implementation follows that guideline.
+ *
+ * @see {@link https://github.com/modelcontextprotocol/modelcontextprotocol/blob/main/docs/specification/2025-03-26/basic/authorization.mdx | MCP Authorization Specification}
+ */
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+// Import core utilities: ErrorHandler for centralized error management and logger for logging.
+import { ErrorHandler, logger } from '../../utils/index.js';
+// --- Stdio Session State ---
+// Since stdio typically involves a single, persistent connection managed by a parent,
+// we manage a single working directory state for the entire process.
+let currentWorkingDirectory = undefined; // Initialize as undefined
+/**
+ * Gets the current working directory set for the stdio session.
+ * @returns {string | undefined} The current working directory path or undefined if not set.
+ */
+export function getStdioWorkingDirectory() {
+    return currentWorkingDirectory;
+}
+/**
+ * Sets the working directory for the stdio session.
+ * @param {string} dir - The new working directory path.
+ */
+export function setStdioWorkingDirectory(dir) {
+    currentWorkingDirectory = dir;
+    logger.info(`Stdio working directory set to: ${dir}`, { operation: 'setStdioWorkingDirectory' });
+}
+/**
+ * Connects a given McpServer instance to the Stdio transport. (Asynchronous)
+ * Initializes the SDK's StdioServerTransport, which handles reading newline-delimited
+ * JSON-RPC messages from process.stdin and writing corresponding messages to process.stdout,
+ * adhering to the MCP stdio transport specification.
+ *
+ * MCP Spec Points Covered by SDK's StdioServerTransport:
+ * - Reads JSON-RPC messages (requests, notifications, responses, batches) from stdin.
+ * - Writes JSON-RPC messages to stdout.
+ * - Handles newline delimiters and ensures no embedded newlines in output messages.
+ * - Ensures only valid MCP messages are written to stdout.
+ *
+ * Note: Logging via the `logger` utility MAY result in output to stderr, which is
+ * permitted by the spec for logging purposes.
+ *
+ * @param {McpServer} server - The McpServer instance containing the core logic (tools, resources).
+ * @param {Record<string, any>} context - Logging context for correlation.
+ * @returns {Promise<void>} A promise that resolves when the connection is successfully established.
+ * @throws {Error} Throws an error if the connection fails during setup (e.g., issues connecting server to transport).
+ */
+export async function connectStdioTransport(server, context) {
+    // Add a specific operation name to the context for better log filtering.
+    const operationContext = { ...context, operation: 'connectStdioTransport', transportType: 'Stdio' };
+    logger.debug('Attempting to connect stdio transport...', operationContext);
+    try {
+        logger.debug('Creating StdioServerTransport instance...', operationContext);
+        // Instantiate the transport provided by the SDK for standard I/O communication.
+        // This class encapsulates the logic for reading from stdin and writing to stdout
+        // according to the MCP stdio spec.
+        const transport = new StdioServerTransport();
+        logger.debug('Connecting McpServer instance to StdioServerTransport...', operationContext);
+        // Establish the link between the server's core logic and the transport layer.
+        // This internally starts the necessary listeners on process.stdin.
+        await server.connect(transport);
+        // Log successful connection. The server is now ready to process messages via stdio.
+        logger.info('MCP Server connected and listening via stdio transport.', operationContext);
+        // Use console.log for prominent startup message visibility when run directly.
+        console.log(`\n🚀 MCP Server running in STDIO mode.\n   (MCP Spec: 2025-03-26 Stdio Transport)\n`);
+    }
+    catch (err) {
+        // Catch and handle any critical errors during the transport connection setup.
+        // Mark as critical because the server cannot function without a connected transport.
+        ErrorHandler.handleError(err, { ...operationContext, critical: true });
+        // Rethrow the error to signal the failure to the calling code (e.g., the main server startup).
+        throw err;
+    }
+}

package/dist/types-global/errors.js

@@ -15,6 +15,8 @@ export var BaseErrorCode;
     BaseErrorCode["CONFLICT"] = "CONFLICT";
     /** The request failed due to invalid input parameters or data. */
     BaseErrorCode["VALIDATION_ERROR"] = "VALIDATION_ERROR";
+    /** An error occurred while parsing input data (e.g., date string, JSON). */
+    BaseErrorCode["PARSING_ERROR"] = "PARSING_ERROR";
     /** The request was rejected because the client has exceeded rate limits. */
     BaseErrorCode["RATE_LIMITED"] = "RATE_LIMITED";
     /** The request timed out before a response could be generated. */
@@ -27,8 +29,6 @@ export var BaseErrorCode;
     BaseErrorCode["UNKNOWN_ERROR"] = "UNKNOWN_ERROR";
     /** An error occurred during the loading or validation of configuration data. */
     BaseErrorCode["CONFIGURATION_ERROR"] = "CONFIGURATION_ERROR";
-    /** An error occurred related to network connectivity (e.g., DNS resolution, connection refused). */
-    BaseErrorCode["NETWORK_ERROR"] = "NETWORK_ERROR";
 })(BaseErrorCode || (BaseErrorCode = {}));
 /**
  * Custom error class for MCP-specific errors.

package/dist/utils/index.js

@@ -1,11 +1,12 @@
-// Re-export all utilities using wildcard exports for simplicity
-export * from './requestContext.js';
-export * from './errorHandler.js';
-export * from './idGenerator.js';
-export * from './logger.js';
-export * from './rateLimiter.js';
-export * from './sanitization.js';
-export * from './tokenCounter.js';
-export * from './jsonParser.js';
-// No need for explicit named imports/exports or default export
-// when using wildcard exports for a simple barrel file.
+// Re-export all utilities from their categorized subdirectories
+export * from './internal/index.js';
+export * from './parsing/index.js';
+export * from './security/index.js';
+export * from './metrics/index.js';
+// It's good practice to have index.ts files in each subdirectory
+// that export the contents of that directory.
+// Assuming those will be created or already exist.
+// If not, this might need adjustment to export specific files, e.g.:
+// export * from './internal/errorHandler.js';
+// export * from './internal/logger.js';
+// ... etc.

package/dist/utils/{errorHandler.js → internal/errorHandler.js}

@@ -1,6 +1,6 @@
-import { BaseErrorCode, McpError } from '../types-global/errors.js';
+import { BaseErrorCode, McpError } from '../../types-global/errors.js'; // Corrected path
 import { logger } from './logger.js';
-import { sanitizeInputForLogging } from './sanitization.js'; // Updated import
+import { sanitizeInputForLogging } from '../index.js'; // Import from main barrel file
 /**
  * Simple mapper that maps error types to error codes
  */
@@ -115,7 +115,9 @@ export class ErrorHandler {
         if (error instanceof McpError) {
             // Add any additional context
             if (context && Object.keys(context).length > 0) {
-                error.details = { ...error.details, ...context };
+                // Ensure details is an object before spreading
+                const existingDetails = typeof error.details === 'object' && error.details !== null ? error.details : {};
+                error.details = { ...existingDetails, ...context };
             }
             // Log the error with sanitized input
             logger.error(`Error ${operation}: ${error.message}`, {
@@ -129,13 +131,14 @@ export class ErrorHandler {
             if (rethrow) {
                 throw error;
             }
+            // Ensure the function returns an Error type
             return error;
         }
         // Sanitize input for logging
         const sanitizedInput = input ? sanitizeInputForLogging(input) : undefined;
         // Log the error with consistent format
         logger.error(`Error ${operation}`, {
-            error: error instanceof Error ? error.message : String(error),
+            error: getErrorMessage(error), // Use helper function
             errorType: getErrorName(error),
             input: sanitizedInput,
             requestId: context?.requestId,
@@ -148,16 +151,22 @@ export class ErrorHandler {
             ErrorHandler.determineErrorCode(error) ||
             BaseErrorCode.INTERNAL_ERROR;
         // Transform to appropriate error type
-        const transformedError = options.errorMapper
-            ? options.errorMapper(error)
-            : new McpError(errorCode, `Error ${operation}: ${error instanceof Error ? error.message : 'Unknown error'}`, {
+        let transformedError;
+        if (options.errorMapper) {
+            transformedError = options.errorMapper(error);
+        }
+        else {
+            transformedError = new McpError(errorCode, `Error ${operation}: ${getErrorMessage(error)}`, // Use helper function
+            {
                 originalError: getErrorName(error),
                 ...context
             });
+        }
         // Rethrow if requested
         if (rethrow) {
             throw transformedError;
         }
+        // Ensure the function returns an Error type
         return transformedError;
     }
     /**
@@ -204,7 +213,8 @@ export class ErrorHandler {
             return {
                 code: error.code,
                 message: error.message,
-                details: error.details || {}
+                // Ensure details is an object
+                details: typeof error.details === 'object' && error.details !== null ? error.details : {}
             };
         }
         if (error instanceof Error) {

package/dist/utils/internal/index.js

@@ -0,0 +1,3 @@
+export * from './errorHandler.js';
+export * from './logger.js';
+export * from './requestContext.js';

package/dist/utils/internal/logger.js

@@ -0,0 +1,254 @@
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import winston from 'winston';
+import { config } from '../../config/index.js';
+// Define the numeric severity for comparison (lower is more severe)
+const mcpLevelSeverity = {
+    emerg: 0, alert: 1, crit: 2, error: 3, warning: 4, notice: 5, info: 6, debug: 7
+};
+// Map MCP levels to Winston's core levels for file logging
+const mcpToWinstonLevel = {
+    debug: 'debug',
+    info: 'info',
+    notice: 'info', // Map notice to info for file logging
+    warning: 'warn',
+    error: 'error',
+    crit: 'error', // Map critical levels to error for file logging
+    alert: 'error',
+    emerg: 'error',
+};
+// Resolve __dirname for ESM
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+// Calculate project root robustly (works from src/ or dist/)
+const isRunningFromDist = __dirname.includes(path.sep + 'dist' + path.sep);
+const levelsToGoUp = isRunningFromDist ? 3 : 2;
+const pathSegments = Array(levelsToGoUp).fill('..');
+const projectRoot = path.resolve(__dirname, ...pathSegments);
+const logsDir = path.join(projectRoot, 'logs');
+// Security: ensure logsDir is within projectRoot
+const resolvedLogsDir = path.resolve(logsDir);
+const isLogsDirSafe = resolvedLogsDir === projectRoot || resolvedLogsDir.startsWith(projectRoot + path.sep);
+if (!isLogsDirSafe) {
+    // Use console.error here as logger might not be initialized or safe
+    console.error(`FATAL: logs directory "${resolvedLogsDir}" is outside project root "${projectRoot}". File logging disabled.`);
+}
+/**
+ * Singleton Logger wrapping Winston, adapted for MCP.
+ * Logs to files and optionally sends MCP notifications/message.
+ */
+class Logger {
+    static instance;
+    winstonLogger;
+    initialized = false;
+    mcpNotificationSender;
+    currentMcpLevel = 'info'; // Default MCP level
+    currentWinstonLevel = 'info'; // Default Winston level
+    constructor() { }
+    /**
+     * Initialize Winston logger for file transport. Must be called once at app start.
+     * Console transport is added conditionally.
+     * @param level Initial minimum level to log ('info' default).
+     */
+    async initialize(level = 'info') {
+        if (this.initialized) {
+            console.warn('Logger already initialized.');
+            return;
+        }
+        this.currentMcpLevel = level;
+        this.currentWinstonLevel = mcpToWinstonLevel[level];
+        // Ensure logs directory exists
+        if (isLogsDirSafe) {
+            try {
+                if (!fs.existsSync(resolvedLogsDir)) {
+                    fs.mkdirSync(resolvedLogsDir, { recursive: true });
+                    console.log(`Created logs directory: ${resolvedLogsDir}`);
+                }
+            }
+            catch (err) {
+                console.error(`Error creating logs directory at ${resolvedLogsDir}: ${err.message}. File logging disabled.`);
+            }
+        }
+        // Common format for files
+        const fileFormat = winston.format.combine(winston.format.timestamp(), winston.format.errors({ stack: true }), winston.format.json());
+        const transports = [];
+        // Add file transports only if the directory is safe
+        if (isLogsDirSafe) {
+            transports.push(new winston.transports.File({ filename: path.join(resolvedLogsDir, 'error.log'), level: 'error', format: fileFormat }), new winston.transports.File({ filename: path.join(resolvedLogsDir, 'warn.log'), level: 'warn', format: fileFormat }), new winston.transports.File({ filename: path.join(resolvedLogsDir, 'info.log'), level: 'info', format: fileFormat }), new winston.transports.File({ filename: path.join(resolvedLogsDir, 'debug.log'), level: 'debug', format: fileFormat }), new winston.transports.File({ filename: path.join(resolvedLogsDir, 'combined.log'), format: fileFormat }));
+        }
+        else {
+            console.warn("File logging disabled due to unsafe logs directory path.");
+        }
+        // Conditionally add Console transport only if:
+        // 1. MCP level is 'debug'
+        // 2. stdout is a TTY (interactive terminal, not piped)
+        if (this.currentMcpLevel === 'debug' && process.stdout.isTTY) {
+            const consoleFormat = winston.format.combine(winston.format.colorize(), winston.format.timestamp({ format: 'YYYY-MM-DD HH:mm:ss' }), winston.format.printf(({ timestamp, level, message, ...meta }) => {
+                let metaString = '';
+                const metaCopy = { ...meta };
+                if (metaCopy.error && typeof metaCopy.error === 'object') {
+                    const errorObj = metaCopy.error;
+                    if (errorObj.message)
+                        metaString += `\n  Error: ${errorObj.message}`;
+                    if (errorObj.stack)
+                        metaString += `\n  Stack: ${String(errorObj.stack).split('\n').map((l) => `    ${l}`).join('\n')}`;
+                    delete metaCopy.error;
+                }
+                if (Object.keys(metaCopy).length > 0) {
+                    try {
+                        const remainingMetaJson = JSON.stringify(metaCopy, null, 2);
+                        if (remainingMetaJson !== '{}')
+                            metaString += `\n  Meta: ${remainingMetaJson}`;
+                    }
+                    catch (stringifyError) {
+                        metaString += `\n  Meta: [Error stringifying metadata: ${stringifyError.message}]`;
+                    }
+                }
+                return `${timestamp} ${level}: ${message}${metaString}`;
+            }));
+            transports.push(new winston.transports.Console({
+                level: 'debug',
+                format: consoleFormat,
+            }));
+            console.log(`Console logging enabled at level: debug (stdout is TTY)`);
+        }
+        else if (this.currentMcpLevel === 'debug' && !process.stdout.isTTY) {
+            console.log(`Console logging skipped: Level is debug, but stdout is not a TTY (likely stdio transport).`);
+        }
+        // Create logger with the initial Winston level and configured transports
+        this.winstonLogger = winston.createLogger({
+            level: this.currentWinstonLevel,
+            transports,
+            exitOnError: false
+        });
+        this.initialized = true;
+        await Promise.resolve(); // Yield to event loop
+        this.info(`Logger initialized. File logging level: ${this.currentWinstonLevel}. MCP logging level: ${this.currentMcpLevel}. Console logging: ${process.stdout.isTTY && this.currentMcpLevel === 'debug' ? 'enabled' : 'disabled'}`);
+    }
+    /**
+     * Sets the function used to send MCP 'notifications/message'.
+     */
+    setMcpNotificationSender(sender) {
+        this.mcpNotificationSender = sender;
+        const status = sender ? 'enabled' : 'disabled';
+        this.info(`MCP notification sending ${status}.`);
+    }
+    /**
+     * Dynamically sets the minimum logging level.
+     */
+    setLevel(newLevel) {
+        if (!this.ensureInitialized()) {
+            console.error("Cannot set level: Logger not initialized.");
+            return;
+        }
+        if (!(newLevel in mcpLevelSeverity)) {
+            this.warning(`Invalid MCP log level provided: ${newLevel}. Level not changed.`);
+            return;
+        }
+        const oldLevel = this.currentMcpLevel;
+        this.currentMcpLevel = newLevel;
+        this.currentWinstonLevel = mcpToWinstonLevel[newLevel];
+        this.winstonLogger.level = this.currentWinstonLevel;
+        // Add or remove console transport based on the new level and TTY status
+        const consoleTransport = this.winstonLogger.transports.find(t => t instanceof winston.transports.Console);
+        const shouldHaveConsole = newLevel === 'debug' && process.stdout.isTTY;
+        if (shouldHaveConsole && !consoleTransport) {
+            // Add console transport
+            const consoleFormat = winston.format.combine( /* ... same format as in initialize ... */); // TODO: Extract format to avoid duplication
+            this.winstonLogger.add(new winston.transports.Console({ level: 'debug', format: consoleFormat }));
+            this.info('Console logging dynamically enabled.');
+        }
+        else if (!shouldHaveConsole && consoleTransport) {
+            // Remove console transport
+            this.winstonLogger.remove(consoleTransport);
+            this.info('Console logging dynamically disabled.');
+        }
+        if (oldLevel !== newLevel) {
+            this.info(`Log level changed. File logging level: ${this.currentWinstonLevel}. MCP logging level: ${this.currentMcpLevel}. Console logging: ${shouldHaveConsole ? 'enabled' : 'disabled'}`);
+        }
+    }
+    /** Get singleton instance. */
+    static getInstance() {
+        if (!Logger.instance) {
+            Logger.instance = new Logger();
+        }
+        return Logger.instance;
+    }
+    /** Ensures the logger has been initialized. */
+    ensureInitialized() {
+        if (!this.initialized || !this.winstonLogger) {
+            console.warn('Logger not initialized; message dropped.');
+            return false;
+        }
+        return true;
+    }
+    /** Centralized log processing */
+    log(level, msg, context, error) {
+        if (!this.ensureInitialized())
+            return;
+        if (mcpLevelSeverity[level] > mcpLevelSeverity[this.currentMcpLevel]) {
+            return;
+        }
+        const logData = { ...context };
+        const winstonLevel = mcpToWinstonLevel[level];
+        if (error) {
+            this.winstonLogger.log(winstonLevel, msg, { ...logData, error: error });
+        }
+        else {
+            this.winstonLogger.log(winstonLevel, msg, logData);
+        }
+        if (this.mcpNotificationSender) {
+            const mcpDataPayload = { message: msg };
+            if (context)
+                mcpDataPayload.context = context;
+            if (error) {
+                mcpDataPayload.error = { message: error.message };
+                if (this.currentMcpLevel === 'debug' && error.stack) {
+                    mcpDataPayload.error.stack = error.stack.substring(0, 500);
+                }
+            }
+            try {
+                this.mcpNotificationSender(level, mcpDataPayload, config.mcpServerName);
+            }
+            catch (sendError) {
+                this.winstonLogger.error("Failed to send MCP log notification", {
+                    originalLevel: level,
+                    originalMessage: msg,
+                    sendError: sendError instanceof Error ? sendError.message : String(sendError),
+                    mcpPayload: mcpDataPayload
+                });
+            }
+        }
+    }
+    // --- Public Logging Methods ---
+    debug(msg, context) { this.log('debug', msg, context); }
+    info(msg, context) { this.log('info', msg, context); }
+    notice(msg, context) { this.log('notice', msg, context); }
+    warning(msg, context) { this.log('warning', msg, context); }
+    error(msg, err, context) {
+        const errorObj = err instanceof Error ? err : undefined;
+        const combinedContext = err instanceof Error ? context : { ...(err || {}), ...(context || {}) };
+        this.log('error', msg, combinedContext, errorObj);
+    }
+    crit(msg, err, context) {
+        const errorObj = err instanceof Error ? err : undefined;
+        const combinedContext = err instanceof Error ? context : { ...(err || {}), ...(context || {}) };
+        this.log('crit', msg, combinedContext, errorObj);
+    }
+    alert(msg, err, context) {
+        const errorObj = err instanceof Error ? err : undefined;
+        const combinedContext = err instanceof Error ? context : { ...(err || {}), ...(context || {}) };
+        this.log('alert', msg, combinedContext, errorObj);
+    }
+    emerg(msg, err, context) {
+        const errorObj = err instanceof Error ? err : undefined;
+        const combinedContext = err instanceof Error ? context : { ...(err || {}), ...(context || {}) };
+        this.log('emerg', msg, combinedContext, errorObj);
+    }
+    fatal(msg, context, error) {
+        this.log('emerg', msg, context, error);
+    }
+}
+// Export singleton instance
+export const logger = Logger.getInstance();

package/dist/utils/{requestContext.js → internal/requestContext.js}

@@ -1,5 +1,6 @@
 import { logger } from './logger.js';
-import { generateUUID } from './idGenerator.js'; // Import generateUUID
+// Import utils from the main barrel file (generateUUID from ../security/idGenerator.js)
+import { generateUUID } from '../index.js';
 // Direct instance for request context utilities
 const requestContextServiceInstance = {
     config: {},
@@ -39,8 +40,6 @@ const requestContextServiceInstance = {
     },
     // generateSecureRandomString function removed as it was unused and redundant
 };
-// Initialize logger message
-logger.debug('RequestContext service initialized');
 // Export the instance directly
 export const requestContextService = requestContextServiceInstance;
 // Removed delegate functions and default export for simplicity.

package/dist/utils/metrics/index.js

@@ -0,0 +1 @@
+export * from './tokenCounter.js';

package/dist/utils/{tokenCounter.js → metrics/tokenCounter.js}

@@ -1,7 +1,7 @@
 import { encoding_for_model } from 'tiktoken';
-import { BaseErrorCode } from '../types-global/errors.js'; // Import BaseErrorCode and McpError
-import { ErrorHandler } from './errorHandler.js'; // Import ErrorHandler
-import { logger } from './logger.js';
+import { BaseErrorCode } from '../../types-global/errors.js';
+// Import utils from the main barrel file (ErrorHandler, logger, RequestContext from ../internal/*)
+import { ErrorHandler, logger } from '../index.js';
 // Define the model used specifically for token counting
 const TOKENIZATION_MODEL = 'gpt-4o'; // Note this is strictly for token counting, not the model used for inference
 /**

package/dist/utils/parsing/dateParser.js

@@ -0,0 +1,62 @@
+import * as chrono from 'chrono-node';
+// Import utils from the main barrel file (logger, ErrorHandler, RequestContext from ../internal/*)
+import { logger, ErrorHandler } from '../index.js';
+import { BaseErrorCode } from '../../types-global/errors.js'; // Corrected path
+/**
+ * Parses a natural language date string into a Date object.
+ *
+ * @param text The natural language date string (e.g., "tomorrow", "in 5 days", "2024-01-15").
+ * @param context The request context for logging and error tracking.
+ * @param refDate Optional reference date for parsing relative dates. Defaults to now.
+ * @returns A Date object representing the parsed date, or null if parsing fails.
+ * @throws McpError if parsing fails unexpectedly.
+ */
+async function parseDateString(text, context, refDate) {
+    const operation = 'parseDateString';
+    const logContext = { ...context, operation, inputText: text, refDate };
+    logger.debug(`Attempting to parse date string: "${text}"`, logContext);
+    return await ErrorHandler.tryCatch(async () => {
+        const parsedDate = chrono.parseDate(text, refDate, { forwardDate: true });
+        if (parsedDate) {
+            logger.debug(`Successfully parsed "${text}" to ${parsedDate.toISOString()}`, logContext);
+            return parsedDate;
+        }
+        else {
+            logger.warning(`Failed to parse date string: "${text}"`, logContext);
+            return null;
+        }
+    }, {
+        operation,
+        context: logContext,
+        input: { text, refDate },
+        errorCode: BaseErrorCode.PARSING_ERROR,
+    });
+}
+/**
+ * Parses a natural language date string and returns detailed parsing results.
+ *
+ * @param text The natural language date string.
+ * @param context The request context for logging and error tracking.
+ * @param refDate Optional reference date for parsing relative dates. Defaults to now.
+ * @returns An array of chrono.ParsedResult objects, or an empty array if parsing fails.
+ * @throws McpError if parsing fails unexpectedly.
+ */
+async function parseDateStringDetailed(text, context, refDate) {
+    const operation = 'parseDateStringDetailed';
+    const logContext = { ...context, operation, inputText: text, refDate };
+    logger.debug(`Attempting detailed parse of date string: "${text}"`, logContext);
+    return await ErrorHandler.tryCatch(async () => {
+        const results = chrono.parse(text, refDate, { forwardDate: true });
+        logger.debug(`Detailed parse of "${text}" resulted in ${results.length} result(s)`, logContext);
+        return results;
+    }, {
+        operation,
+        context: logContext,
+        input: { text, refDate },
+        errorCode: BaseErrorCode.PARSING_ERROR,
+    });
+}
+export const dateParser = {
+    parse: parseDateStringDetailed,
+    parseDate: parseDateString,
+};

package/dist/utils/parsing/index.js

@@ -0,0 +1,2 @@
+export * from './jsonParser.js';
+export * from './dateParser.js';

package/dist/utils/{jsonParser.js → parsing/jsonParser.js}

@@ -1,6 +1,7 @@
 import { parse as parsePartialJson, Allow as PartialJsonAllow } from 'partial-json';
-import { BaseErrorCode, McpError } from '../types-global/errors.js';
-import { logger } from './logger.js'; // Import logger
+import { BaseErrorCode, McpError } from '../../types-global/errors.js';
+// Import utils from the main barrel file (logger, RequestContext from ../internal/*)
+import { logger } from '../index.js';
 /**
  * Enum mirroring partial-json's Allow constants for specifying
  * what types of partial JSON structures are permissible during parsing.

package/dist/utils/{idGenerator.js → security/idGenerator.js}

@@ -1,6 +1,5 @@
-import { randomBytes } from 'crypto';
-import { BaseErrorCode, McpError } from '../types-global/errors.js';
-import { logger } from './logger.js';
+import { randomBytes, randomUUID as cryptoRandomUUID } from 'crypto'; // Import cryptoRandomUUID
+import { BaseErrorCode, McpError } from '../../types-global/errors.js'; // Corrected path
 /**
  * Generic ID Generator class for creating and managing unique identifiers
  */
@@ -34,7 +33,7 @@ export class IdGenerator {
             acc[prefix.toLowerCase()] = type;
             return acc;
         }, {});
-        logger.debug('Entity prefixes updated', { entityPrefixes: this.entityPrefixes });
+        // Removed logger call from setEntityPrefixes to prevent logging before initialization
     }
     /**
      * Get all registered entity prefixes
@@ -144,5 +143,5 @@ export class IdGenerator {
 export const idGenerator = new IdGenerator();
 // For standalone use as a UUID generator
 export const generateUUID = () => {
-    return crypto.randomUUID();
+    return cryptoRandomUUID(); // Use imported cryptoRandomUUID
 };

package/dist/utils/security/index.js

@@ -0,0 +1,3 @@
+export * from './sanitization.js';
+export * from './rateLimiter.js';
+export * from './idGenerator.js';

package/dist/utils/{rateLimiter.js → security/rateLimiter.js}

@@ -1,5 +1,7 @@
-import { BaseErrorCode, McpError } from '../types-global/errors.js';
-import { logger } from './logger.js';
+import { BaseErrorCode, McpError } from '../../types-global/errors.js';
+// Import config and utils
+import { environment } from '../../config/index.js'; // Import environment from config
+import { logger } from '../index.js';
 /**
  * Generic rate limiter that can be used across the application
  */
@@ -26,12 +28,7 @@ export class RateLimiter {
         this.config = { ...RateLimiter.DEFAULT_CONFIG, ...config };
         this.limits = new Map();
         this.startCleanupTimer();
-        // Log initialization
-        logger.debug('RateLimiter initialized', {
-            windowMs: this.config.windowMs,
-            maxRequests: this.config.maxRequests,
-            cleanupInterval: this.config.cleanupInterval
-        });
+        // Removed logger call from constructor to prevent logging before initialization
     }
     /**
      * Start the cleanup timer to periodically remove expired entries
@@ -102,8 +99,8 @@ export class RateLimiter {
      * @throws {McpError} If rate limit is exceeded
      */
     check(key, context) {
-        // Skip in development if configured
-        if (this.config.skipInDevelopment && process.env.NODE_ENV === 'development') {
+        // Skip in development if configured, using the validated environment from config
+        if (this.config.skipInDevelopment && environment === 'development') {
             return;
         }
         // Generate key using custom generator if provided