latitude-mcp-server 1.0.0

package/dist/utils/formatter.util.js

@@ -0,0 +1,116 @@
+"use strict";
+/**
+ * Standardized formatting utilities for consistent output across all CLI and Tool interfaces.
+ * These functions should be used by all formatters to ensure consistent formatting.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatDate = formatDate;
+exports.formatUrl = formatUrl;
+exports.formatHeading = formatHeading;
+exports.formatBulletList = formatBulletList;
+exports.formatSeparator = formatSeparator;
+/**
+ * Format a date in a standardized way: YYYY-MM-DD HH:MM:SS UTC
+ * @param dateString - ISO date string or Date object
+ * @returns Formatted date string
+ */
+function formatDate(dateString) {
+    if (!dateString) {
+        return 'Not available';
+    }
+    try {
+        const date = typeof dateString === 'string' ? new Date(dateString) : dateString;
+        // Format: YYYY-MM-DD HH:MM:SS UTC
+        return date
+            .toISOString()
+            .replace('T', ' ')
+            .replace(/\.\d+Z$/, ' UTC');
+    }
+    catch {
+        return 'Invalid date';
+    }
+}
+/**
+ * Format a URL as a markdown link
+ * @param url - URL to format
+ * @param title - Link title
+ * @returns Formatted markdown link
+ */
+function formatUrl(url, title) {
+    if (!url) {
+        return 'Not available';
+    }
+    const linkTitle = title || url;
+    return `[${linkTitle}](${url})`;
+}
+/**
+ * Format a heading with consistent style
+ * @param text - Heading text
+ * @param level - Heading level (1-6)
+ * @returns Formatted heading
+ */
+function formatHeading(text, level = 1) {
+    const validLevel = Math.min(Math.max(level, 1), 6);
+    const prefix = '#'.repeat(validLevel);
+    return `${prefix} ${text}`;
+}
+/**
+ * Format a list of key-value pairs as a bullet list
+ * @param items - Object with key-value pairs
+ * @param keyFormatter - Optional function to format keys
+ * @returns Formatted bullet list
+ */
+function formatBulletList(items, keyFormatter) {
+    const lines = [];
+    for (const [key, value] of Object.entries(items)) {
+        if (value === undefined || value === null) {
+            continue;
+        }
+        const formattedKey = keyFormatter ? keyFormatter(key) : key;
+        const formattedValue = formatValue(value);
+        lines.push(`- **${formattedKey}**: ${formattedValue}`);
+    }
+    return lines.join('\n');
+}
+/**
+ * Format a value based on its type
+ * @param value - Value to format
+ * @returns Formatted value
+ */
+function formatValue(value) {
+    if (value === undefined || value === null) {
+        return 'Not available';
+    }
+    if (value instanceof Date) {
+        return formatDate(value);
+    }
+    // Handle URL objects with url and title properties
+    if (typeof value === 'object' && value !== null && 'url' in value) {
+        const urlObj = value;
+        if (typeof urlObj.url === 'string') {
+            return formatUrl(urlObj.url, urlObj.title);
+        }
+    }
+    if (typeof value === 'string') {
+        // Check if it's a URL
+        if (value.startsWith('http://') || value.startsWith('https://')) {
+            return formatUrl(value);
+        }
+        // Check if it might be a date
+        if (/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}/.test(value)) {
+            return formatDate(value);
+        }
+        return value;
+    }
+    if (typeof value === 'boolean') {
+        return value ? 'Yes' : 'No';
+    }
+    return String(value);
+}
+/**
+ * Format a separator line
+ * @returns Separator line
+ */
+function formatSeparator() {
+    return '---';
+}

package/dist/utils/jest.setup.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Jest global setup for suppressing console output during tests
+ * This file is used to mock console methods to reduce noise in test output
+ */
+export {};

package/dist/utils/jest.setup.js

@@ -0,0 +1,36 @@
+"use strict";
+/**
+ * Jest global setup for suppressing console output during tests
+ * This file is used to mock console methods to reduce noise in test output
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const globals_1 = require("@jest/globals");
+// Store original console methods
+const originalConsole = {
+    log: console.log,
+    info: console.info,
+    warn: console.warn,
+    error: console.error,
+    debug: console.debug,
+};
+// Global setup to suppress console output during tests
+(0, globals_1.beforeEach)(() => {
+    // Mock console methods to suppress output
+    console.log = globals_1.jest.fn();
+    console.info = globals_1.jest.fn();
+    console.warn = globals_1.jest.fn();
+    console.error = globals_1.jest.fn();
+    console.debug = globals_1.jest.fn();
+});
+(0, globals_1.afterEach)(() => {
+    // Clear mock calls after each test
+    globals_1.jest.clearAllMocks();
+});
+(0, globals_1.afterAll)(() => {
+    // Restore original console methods after all tests
+    console.log = originalConsole.log;
+    console.info = originalConsole.info;
+    console.warn = originalConsole.warn;
+    console.error = originalConsole.error;
+    console.debug = originalConsole.debug;
+});

package/dist/utils/jq.util.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Apply a JMESPath filter to JSON data
+ *
+ * @param data - The data to filter (any JSON-serializable value)
+ * @param filter - JMESPath expression to apply
+ * @returns Filtered data or original data if filter is empty/invalid
+ *
+ * @example
+ * // Get single field
+ * applyJqFilter(data, "name")
+ *
+ * // Get nested field
+ * applyJqFilter(data, "body.storage.value")
+ *
+ * // Get multiple fields as object
+ * applyJqFilter(data, "{id: id, title: title}")
+ *
+ * // Array operations
+ * applyJqFilter(data, "results[*].title")
+ */
+export declare function applyJqFilter(data: unknown, filter?: string): unknown;
+/**
+ * Convert data to output string for MCP response
+ *
+ * By default, converts to TOON format (Token-Oriented Object Notation)
+ * for improved LLM token efficiency (30-60% fewer tokens).
+ * Falls back to JSON if TOON conversion fails or if useToon is false.
+ *
+ * @param data - The data to convert
+ * @param useToon - Whether to use TOON format (default: true)
+ * @param pretty - Whether to pretty-print JSON (default: true)
+ * @returns TOON formatted string (default), or JSON string
+ */
+export declare function toOutputString(data: unknown, useToon?: boolean, pretty?: boolean): Promise<string>;

package/dist/utils/jq.util.js

@@ -0,0 +1,87 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.applyJqFilter = applyJqFilter;
+exports.toOutputString = toOutputString;
+const jmespath_1 = __importDefault(require("jmespath"));
+const logger_util_js_1 = require("./logger.util.js");
+const toon_util_js_1 = require("./toon.util.js");
+const logger = logger_util_js_1.Logger.forContext('utils/jq.util.ts');
+/**
+ * Apply a JMESPath filter to JSON data
+ *
+ * @param data - The data to filter (any JSON-serializable value)
+ * @param filter - JMESPath expression to apply
+ * @returns Filtered data or original data if filter is empty/invalid
+ *
+ * @example
+ * // Get single field
+ * applyJqFilter(data, "name")
+ *
+ * // Get nested field
+ * applyJqFilter(data, "body.storage.value")
+ *
+ * // Get multiple fields as object
+ * applyJqFilter(data, "{id: id, title: title}")
+ *
+ * // Array operations
+ * applyJqFilter(data, "results[*].title")
+ */
+function applyJqFilter(data, filter) {
+    const methodLogger = logger.forMethod('applyJqFilter');
+    // Return original data if no filter provided
+    if (!filter || filter.trim() === '') {
+        methodLogger.debug('No filter provided, returning original data');
+        return data;
+    }
+    try {
+        methodLogger.debug(`Applying JMESPath filter: ${filter}`);
+        const result = jmespath_1.default.search(data, filter);
+        methodLogger.debug('Filter applied successfully');
+        return result;
+    }
+    catch (error) {
+        methodLogger.error(`Invalid JMESPath expression: ${filter}`, error);
+        // Return original data with error info if filter is invalid
+        return {
+            _jqError: `Invalid JMESPath expression: ${filter}`,
+            _originalData: data,
+        };
+    }
+}
+/**
+ * Convert data to JSON string for MCP response
+ *
+ * @param data - The data to stringify
+ * @param pretty - Whether to pretty-print the JSON (default: true)
+ * @returns JSON string
+ */
+function toJsonString(data, pretty = true) {
+    if (pretty) {
+        return JSON.stringify(data, null, 2);
+    }
+    return JSON.stringify(data);
+}
+/**
+ * Convert data to output string for MCP response
+ *
+ * By default, converts to TOON format (Token-Oriented Object Notation)
+ * for improved LLM token efficiency (30-60% fewer tokens).
+ * Falls back to JSON if TOON conversion fails or if useToon is false.
+ *
+ * @param data - The data to convert
+ * @param useToon - Whether to use TOON format (default: true)
+ * @param pretty - Whether to pretty-print JSON (default: true)
+ * @returns TOON formatted string (default), or JSON string
+ */
+async function toOutputString(data, useToon = true, pretty = true) {
+    const jsonString = toJsonString(data, pretty);
+    // Return JSON directly if TOON is not requested
+    if (!useToon) {
+        return jsonString;
+    }
+    // Try TOON conversion with JSON fallback
+    return (0, toon_util_js_1.toToonOrJson)(data, jsonString);
+}

package/dist/utils/logger.util.d.ts

@@ -0,0 +1,78 @@
+/**
+ * Logger class for consistent logging across the application.
+ *
+ * RECOMMENDED USAGE:
+ *
+ * 1. Create a file-level logger using the static forContext method:
+ *    ```
+ *    const logger = Logger.forContext('controllers/myController.ts');
+ *    ```
+ *
+ * 2. For method-specific logging, create a method logger:
+ *    ```
+ *    const methodLogger = Logger.forContext('controllers/myController.ts', 'myMethod');
+ *    ```
+ *
+ * 3. Avoid using raw string prefixes in log messages. Instead, use contextualized loggers.
+ *
+ * 4. For debugging objects, use the debugResponse method to log only essential properties.
+ *
+ * 5. Set DEBUG environment variable to control which modules show debug logs:
+ *    - DEBUG=true (enable all debug logs)
+ *    - DEBUG=controllers/*,services/* (enable for specific module groups)
+ *    - DEBUG=transport,utils/formatter* (enable specific modules, supports wildcards)
+ */
+declare class Logger {
+    private context?;
+    private modulePath;
+    private static sessionId;
+    private static logFilePath;
+    constructor(context?: string, modulePath?: string);
+    /**
+     * Create a contextualized logger for a specific file or component.
+     * This is the preferred method for creating loggers.
+     *
+     * @param filePath The file path (e.g., 'controllers/aws.sso.auth.controller.ts')
+     * @param functionName Optional function name for more specific context
+     * @returns A new Logger instance with the specified context
+     *
+     * @example
+     * // File-level logger
+     * const logger = Logger.forContext('controllers/myController.ts');
+     *
+     * // Method-level logger
+     * const methodLogger = Logger.forContext('controllers/myController.ts', 'myMethod');
+     */
+    static forContext(filePath: string, functionName?: string): Logger;
+    /**
+     * Create a method level logger from a context logger
+     * @param method Method name
+     * @returns A new logger with the method context
+     */
+    forMethod(method: string): Logger;
+    private _formatMessage;
+    private _formatArgs;
+    _log(level: 'info' | 'warn' | 'error' | 'debug', message: string, ...args: unknown[]): void;
+    info(message: string, ...args: unknown[]): void;
+    warn(message: string, ...args: unknown[]): void;
+    error(message: string, ...args: unknown[]): void;
+    debug(message: string, ...args: unknown[]): void;
+    /**
+     * Log essential information about an API response
+     * @param message Log message
+     * @param response API response object
+     * @param essentialKeys Keys to extract from the response
+     */
+    debugResponse(message: string, response: Record<string, unknown>, essentialKeys: string[]): void;
+    /**
+     * Get the current session ID
+     * @returns The UUID for the current logging session
+     */
+    static getSessionId(): string;
+    /**
+     * Get the current log file path
+     * @returns The path to the current log file
+     */
+    static getLogFilePath(): string;
+}
+export { Logger };