snow-ai 0.1.12 → 0.2.2

package/dist/utils/fileUtils.js

@@ -0,0 +1,222 @@
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+/**
+ * Get line count for a file
+ */
+export function getFileLineCount(filePath) {
+    return new Promise((resolve) => {
+        try {
+            if (!fs.existsSync(filePath)) {
+                resolve(0);
+                return;
+            }
+            const content = fs.readFileSync(filePath, 'utf-8');
+            const lines = content.split('\n').length;
+            resolve(lines);
+        }
+        catch (error) {
+            resolve(0);
+        }
+    });
+}
+/**
+ * Check if file is an image based on extension
+ */
+function isImageFile(filePath) {
+    const imageExtensions = ['.png', '.jpg', '.jpeg', '.gif', '.webp', '.bmp', '.svg'];
+    const ext = path.extname(filePath).toLowerCase();
+    return imageExtensions.includes(ext);
+}
+/**
+ * Get MIME type from file extension
+ */
+function getMimeType(filePath) {
+    const ext = path.extname(filePath).toLowerCase();
+    const mimeTypes = {
+        '.png': 'image/png',
+        '.jpg': 'image/jpeg',
+        '.jpeg': 'image/jpeg',
+        '.gif': 'image/gif',
+        '.webp': 'image/webp',
+        '.bmp': 'image/bmp',
+        '.svg': 'image/svg+xml'
+    };
+    return mimeTypes[ext] || 'application/octet-stream';
+}
+/**
+ * Get file information including line count
+ */
+export async function getFileInfo(filePath) {
+    try {
+        // Try multiple path resolutions in order of preference
+        const pathsToTry = [
+            filePath, // Original path as provided
+            path.resolve(process.cwd(), filePath), // Relative to current working directory
+            path.resolve(filePath), // Absolute resolution
+        ];
+        // Remove duplicates while preserving order
+        const uniquePaths = [...new Set(pathsToTry)];
+        let actualPath = filePath;
+        let exists = false;
+        // Try each path until we find one that exists
+        for (const tryPath of uniquePaths) {
+            if (fs.existsSync(tryPath)) {
+                actualPath = tryPath;
+                exists = true;
+                break;
+            }
+        }
+        // Check if it's an image file
+        const isImage = isImageFile(actualPath);
+        let imageData;
+        let mimeType;
+        let lineCount = 0;
+        if (exists) {
+            if (isImage) {
+                // Read image as base64
+                const buffer = fs.readFileSync(actualPath);
+                const base64 = buffer.toString('base64');
+                mimeType = getMimeType(actualPath);
+                imageData = `data:${mimeType};base64,${base64}`;
+            }
+            else {
+                lineCount = await getFileLineCount(actualPath);
+            }
+        }
+        return {
+            path: filePath, // Keep original path for display
+            lineCount,
+            exists,
+            isImage,
+            imageData,
+            mimeType
+        };
+    }
+    catch (error) {
+        return {
+            path: filePath,
+            lineCount: 0,
+            exists: false
+        };
+    }
+}
+/**
+ * Format file tree display for messages
+ */
+export function formatFileTree(files) {
+    if (files.length === 0)
+        return '';
+    return files.map(file => `└─ Read \`${file.path}\`${file.exists ? ` (total line ${file.lineCount})` : ' (file not found)'}`).join('\n');
+}
+/**
+ * Parse @file references from message content and check if they exist
+ * Also supports direct file paths (pasted from VSCode drag & drop)
+ */
+export async function parseAndValidateFileReferences(content) {
+    const foundFiles = [];
+    // Pattern 1: @file references (e.g., @path/to/file.ts)
+    const atFileRegex = /@([A-Za-z0-9\-._/\\:]+\.[a-zA-Z]+)(?=\s|$)/g;
+    let match;
+    while ((match = atFileRegex.exec(content)) !== null) {
+        if (match[1]) {
+            foundFiles.push(match[1]);
+        }
+    }
+    // Pattern 2: Direct absolute/relative paths (e.g., c:\Users\...\file.ts or ./src/file.ts)
+    // Match paths that look like file paths with extensions, but NOT @-prefixed ones
+    const directPathRegex = /(?<!@)(?:^|\s)((?:[a-zA-Z]:[\\\/]|\.{1,2}[\\\/]|[\\\/])(?:[A-Za-z0-9\-._/\\:()[\] ]+)\.[a-zA-Z]+)(?=\s|$)/g;
+    while ((match = directPathRegex.exec(content)) !== null) {
+        if (match[1]) {
+            const trimmedPath = match[1].trim();
+            // Only add if it looks like a real file path
+            if (trimmedPath && !foundFiles.includes(trimmedPath)) {
+                foundFiles.push(trimmedPath);
+            }
+        }
+    }
+    // Remove duplicates
+    const uniqueFiles = [...new Set(foundFiles)];
+    // Check which files actually exist
+    const fileInfos = await Promise.all(uniqueFiles.map(async (filePath) => {
+        const info = await getFileInfo(filePath);
+        return info;
+    }));
+    // Filter only existing files
+    const validFiles = fileInfos.filter(file => file.exists);
+    // Clean content - keep paths as user typed them
+    const cleanContent = content;
+    return {
+        cleanContent,
+        validFiles
+    };
+}
+/**
+ * Create message with file read instructions for AI
+ */
+export function createMessageWithFileInstructions(content, files, systemInfo) {
+    const parts = [content];
+    // Add system info if provided
+    if (systemInfo) {
+        const systemInfoLines = [
+            `└─ Platform: ${systemInfo.platform}`,
+            `└─ Shell: ${systemInfo.shell}`,
+            `└─ Working Directory: ${systemInfo.workingDirectory}`
+        ];
+        parts.push(systemInfoLines.join('\n'));
+    }
+    // Add file instructions if provided
+    if (files.length > 0) {
+        const fileInstructions = files
+            .map(f => `└─ Read \`${f.path}\` (total line ${f.lineCount})`)
+            .join('\n');
+        parts.push(fileInstructions);
+    }
+    return parts.join('\n');
+}
+/**
+ * Get system information (OS, shell, working directory)
+ */
+export function getSystemInfo() {
+    // Get OS platform
+    const platform = (() => {
+        const platformType = os.platform();
+        switch (platformType) {
+            case 'win32':
+                return 'Windows';
+            case 'darwin':
+                return 'macOS';
+            case 'linux':
+                return 'Linux';
+            default:
+                return platformType;
+        }
+    })();
+    // Get shell type
+    const shell = (() => {
+        const shellPath = process.env['SHELL'] || process.env['ComSpec'] || '';
+        const shellName = path.basename(shellPath).toLowerCase();
+        if (shellName.includes('cmd'))
+            return 'cmd.exe';
+        if (shellName.includes('powershell'))
+            return 'PowerShell';
+        if (shellName.includes('pwsh'))
+            return 'PowerShell';
+        if (shellName.includes('zsh'))
+            return 'zsh';
+        if (shellName.includes('bash'))
+            return 'bash';
+        if (shellName.includes('fish'))
+            return 'fish';
+        if (shellName.includes('sh'))
+            return 'sh';
+        return shellName || 'shell';
+    })();
+    // Get working directory
+    const workingDirectory = process.cwd();
+    return {
+        platform,
+        shell,
+        workingDirectory
+    };
+}

package/dist/utils/index.d.ts

@@ -1,4 +1,8 @@
 import { Command } from '../types/index.js';
+import './commands/clear.js';
+import './commands/resume.js';
+export { Logger, LogLevel, logger } from './logger.js';
+export { default as defaultLogger } from './logger.js';
 export declare function formatCommand(command: Command): string;
 export declare function parseInput(input: string): {
     command: string;

package/dist/utils/index.js

@@ -1,3 +1,9 @@
+// Import commands to register them
+import './commands/clear.js';
+import './commands/resume.js';
+// Export logger
+export { Logger, LogLevel, logger } from './logger.js';
+export { default as defaultLogger } from './logger.js';
 export function formatCommand(command) {
     return `${command.name.padEnd(12)} ${command.description}`;
 }

package/dist/utils/logger.d.ts

@@ -0,0 +1,31 @@
+export declare enum LogLevel {
+    ERROR = 0,
+    WARN = 1,
+    INFO = 2,
+    DEBUG = 3
+}
+export interface LoggerConfig {
+    logDir?: string;
+    maxFileSize?: number;
+    dateFormat?: string;
+}
+export declare class Logger {
+    private readonly logDir;
+    private readonly maxFileSize;
+    constructor(config?: LoggerConfig);
+    private ensureLogDirectory;
+    private formatDate;
+    private formatTimestamp;
+    private getLogFilePath;
+    private shouldRotateLog;
+    private rotateLog;
+    private writeLog;
+    error(message: string, meta?: any): void;
+    warn(message: string, meta?: any): void;
+    info(message: string, meta?: any): void;
+    debug(message: string, meta?: any): void;
+    log(level: LogLevel, message: string, meta?: any): void;
+}
+declare const defaultLogger: Logger;
+export default defaultLogger;
+export { defaultLogger as logger };

package/dist/utils/logger.js

@@ -0,0 +1,97 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { homedir } from 'node:os';
+export var LogLevel;
+(function (LogLevel) {
+    LogLevel[LogLevel["ERROR"] = 0] = "ERROR";
+    LogLevel[LogLevel["WARN"] = 1] = "WARN";
+    LogLevel[LogLevel["INFO"] = 2] = "INFO";
+    LogLevel[LogLevel["DEBUG"] = 3] = "DEBUG";
+})(LogLevel || (LogLevel = {}));
+export class Logger {
+    constructor(config = {}) {
+        Object.defineProperty(this, "logDir", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "maxFileSize", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.logDir = config.logDir || path.join(homedir(), '.snow', 'log');
+        this.maxFileSize = config.maxFileSize || 10 * 1024 * 1024; // 10MB
+        this.ensureLogDirectory();
+    }
+    ensureLogDirectory() {
+        if (!fs.existsSync(this.logDir)) {
+            fs.mkdirSync(this.logDir, { recursive: true });
+        }
+    }
+    formatDate(date) {
+        const year = date.getFullYear();
+        const month = String(date.getMonth() + 1).padStart(2, '0');
+        const day = String(date.getDate()).padStart(2, '0');
+        return `${year}-${month}-${day}`;
+    }
+    formatTimestamp(date) {
+        return date.toISOString();
+    }
+    getLogFilePath(level) {
+        const dateString = this.formatDate(new Date());
+        const levelName = LogLevel[level].toLowerCase();
+        return path.join(this.logDir, `${dateString}-${levelName}.log`);
+    }
+    shouldRotateLog(filePath) {
+        if (!fs.existsSync(filePath)) {
+            return false;
+        }
+        const stats = fs.statSync(filePath);
+        return stats.size >= this.maxFileSize;
+    }
+    rotateLog(filePath) {
+        const timestamp = Date.now();
+        const ext = path.extname(filePath);
+        const basename = path.basename(filePath, ext);
+        const dirname = path.dirname(filePath);
+        const rotatedPath = path.join(dirname, `${basename}-${timestamp}${ext}`);
+        fs.renameSync(filePath, rotatedPath);
+    }
+    writeLog(level, message, meta) {
+        const timestamp = this.formatTimestamp(new Date());
+        const levelName = LogLevel[level].toUpperCase().padEnd(5);
+        const logEntry = {
+            timestamp,
+            level: levelName.trim(),
+            message,
+            ...(meta && { meta }),
+        };
+        const logLine = JSON.stringify(logEntry) + '\n';
+        const filePath = this.getLogFilePath(level);
+        if (this.shouldRotateLog(filePath)) {
+            this.rotateLog(filePath);
+        }
+        fs.appendFileSync(filePath, logLine, 'utf8');
+    }
+    error(message, meta) {
+        this.writeLog(LogLevel.ERROR, message, meta);
+    }
+    warn(message, meta) {
+        this.writeLog(LogLevel.WARN, message, meta);
+    }
+    info(message, meta) {
+        this.writeLog(LogLevel.INFO, message, meta);
+    }
+    debug(message, meta) {
+        this.writeLog(LogLevel.DEBUG, message, meta);
+    }
+    log(level, message, meta) {
+        this.writeLog(level, message, meta);
+    }
+}
+const defaultLogger = new Logger();
+export default defaultLogger;
+export { defaultLogger as logger };

package/dist/utils/mcpToolsManager.d.ts

@@ -0,0 +1,47 @@
+import { TodoService } from '../mcp/todo.js';
+export interface MCPTool {
+    type: "function";
+    function: {
+        name: string;
+        description: string;
+        parameters: any;
+    };
+}
+export interface MCPServiceTools {
+    serviceName: string;
+    tools: Array<{
+        name: string;
+        description: string;
+        inputSchema: any;
+    }>;
+    isBuiltIn: boolean;
+    connected: boolean;
+    error?: string;
+}
+/**
+ * Get the TODO service instance
+ */
+export declare function getTodoService(): TodoService;
+/**
+ * Manually refresh the tools cache (for configuration changes)
+ */
+export declare function refreshMCPToolsCache(): Promise<void>;
+/**
+ * Clear the tools cache (useful for testing or forcing refresh)
+ */
+export declare function clearMCPToolsCache(): void;
+/**
+ * Collect all available MCP tools from built-in and user-configured services
+ * Uses caching to avoid reconnecting on every message
+ */
+export declare function collectAllMCPTools(): Promise<MCPTool[]>;
+/**
+ * Get detailed information about all MCP services and their tools
+ * Uses cached data when available
+ */
+export declare function getMCPServicesInfo(): Promise<MCPServiceTools[]>;
+/**
+ * Execute an MCP tool by parsing the prefixed tool name
+ * Only connects to the service when actually needed
+ */
+export declare function executeMCPTool(toolName: string, args: any): Promise<any>;