snow-ai 0.2.25 → 0.2.26

package/dist/utils/configManager.js

@@ -0,0 +1,274 @@
+import { homedir } from 'os';
+import { join } from 'path';
+import { readFileSync, writeFileSync, existsSync, mkdirSync, readdirSync, unlinkSync, } from 'fs';
+import { loadConfig, saveConfig } from './apiConfig.js';
+const CONFIG_DIR = join(homedir(), '.snow');
+const PROFILES_DIR = join(CONFIG_DIR, 'profiles');
+const ACTIVE_PROFILE_FILE = join(CONFIG_DIR, 'active-profile.txt');
+const LEGACY_CONFIG_FILE = join(CONFIG_DIR, 'config.json');
+/**
+ * Ensure the profiles directory exists
+ */
+function ensureProfilesDirectory() {
+    if (!existsSync(CONFIG_DIR)) {
+        mkdirSync(CONFIG_DIR, { recursive: true });
+    }
+    if (!existsSync(PROFILES_DIR)) {
+        mkdirSync(PROFILES_DIR, { recursive: true });
+    }
+}
+/**
+ * Get the current active profile name
+ */
+export function getActiveProfileName() {
+    ensureProfilesDirectory();
+    if (!existsSync(ACTIVE_PROFILE_FILE)) {
+        return 'default';
+    }
+    try {
+        const profileName = readFileSync(ACTIVE_PROFILE_FILE, 'utf8').trim();
+        return profileName || 'default';
+    }
+    catch {
+        return 'default';
+    }
+}
+/**
+ * Set the active profile
+ */
+function setActiveProfileName(profileName) {
+    ensureProfilesDirectory();
+    try {
+        writeFileSync(ACTIVE_PROFILE_FILE, profileName, 'utf8');
+    }
+    catch (error) {
+        throw new Error(`Failed to set active profile: ${error}`);
+    }
+}
+/**
+ * Get the path to a profile file
+ */
+function getProfilePath(profileName) {
+    return join(PROFILES_DIR, `${profileName}.json`);
+}
+/**
+ * Migrate legacy config.json to profiles/default.json
+ * This ensures backward compatibility with existing installations
+ */
+function migrateLegacyConfig() {
+    ensureProfilesDirectory();
+    const defaultProfilePath = getProfilePath('default');
+    // If default profile already exists, no migration needed
+    if (existsSync(defaultProfilePath)) {
+        return;
+    }
+    // If legacy config exists, migrate it
+    if (existsSync(LEGACY_CONFIG_FILE)) {
+        try {
+            const legacyConfig = readFileSync(LEGACY_CONFIG_FILE, 'utf8');
+            writeFileSync(defaultProfilePath, legacyConfig, 'utf8');
+            // Set default as active profile
+            setActiveProfileName('default');
+        }
+        catch (error) {
+            // If migration fails, we'll create a default profile later
+            console.error('Failed to migrate legacy config:', error);
+        }
+    }
+}
+/**
+ * Load a specific profile
+ */
+export function loadProfile(profileName) {
+    ensureProfilesDirectory();
+    migrateLegacyConfig();
+    const profilePath = getProfilePath(profileName);
+    if (!existsSync(profilePath)) {
+        return undefined;
+    }
+    try {
+        const configData = readFileSync(profilePath, 'utf8');
+        return JSON.parse(configData);
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * Save a profile
+ */
+export function saveProfile(profileName, config) {
+    ensureProfilesDirectory();
+    const profilePath = getProfilePath(profileName);
+    try {
+        // Remove openai field for backward compatibility
+        const { openai, ...configWithoutOpenai } = config;
+        const configData = JSON.stringify(configWithoutOpenai, null, 2);
+        writeFileSync(profilePath, configData, 'utf8');
+    }
+    catch (error) {
+        throw new Error(`Failed to save profile: ${error}`);
+    }
+}
+/**
+ * Get all available profiles
+ */
+export function getAllProfiles() {
+    ensureProfilesDirectory();
+    migrateLegacyConfig();
+    const activeProfile = getActiveProfileName();
+    const profiles = [];
+    try {
+        const files = readdirSync(PROFILES_DIR);
+        for (const file of files) {
+            if (file.endsWith('.json')) {
+                const profileName = file.replace('.json', '');
+                const config = loadProfile(profileName);
+                if (config) {
+                    profiles.push({
+                        name: profileName,
+                        displayName: getProfileDisplayName(profileName),
+                        isActive: profileName === activeProfile,
+                        config,
+                    });
+                }
+            }
+        }
+    }
+    catch {
+        // If reading fails, return empty array
+    }
+    // Ensure at least a default profile exists
+    if (profiles.length === 0) {
+        const defaultConfig = loadConfig();
+        saveProfile('default', defaultConfig);
+        profiles.push({
+            name: 'default',
+            displayName: 'Default',
+            isActive: true,
+            config: defaultConfig,
+        });
+        setActiveProfileName('default');
+    }
+    return profiles.sort((a, b) => a.name.localeCompare(b.name));
+}
+/**
+ * Get a user-friendly display name for a profile
+ */
+function getProfileDisplayName(profileName) {
+    // Capitalize first letter
+    return profileName.charAt(0).toUpperCase() + profileName.slice(1);
+}
+/**
+ * Switch to a different profile
+ * This copies the profile config to config.json and updates the active profile
+ */
+export function switchProfile(profileName) {
+    ensureProfilesDirectory();
+    const profileConfig = loadProfile(profileName);
+    if (!profileConfig) {
+        throw new Error(`Profile "${profileName}" not found`);
+    }
+    // Save the profile config to the main config.json (for backward compatibility)
+    saveConfig(profileConfig);
+    // Update the active profile marker
+    setActiveProfileName(profileName);
+}
+/**
+ * Create a new profile
+ */
+export function createProfile(profileName, config) {
+    ensureProfilesDirectory();
+    // Validate profile name
+    if (!profileName.trim() || profileName.includes('/') || profileName.includes('\\')) {
+        throw new Error('Invalid profile name');
+    }
+    const profilePath = getProfilePath(profileName);
+    if (existsSync(profilePath)) {
+        throw new Error(`Profile "${profileName}" already exists`);
+    }
+    // If no config provided, use the current config
+    const profileConfig = config || loadConfig();
+    saveProfile(profileName, profileConfig);
+}
+/**
+ * Delete a profile
+ */
+export function deleteProfile(profileName) {
+    ensureProfilesDirectory();
+    // Don't allow deleting the default profile
+    if (profileName === 'default') {
+        throw new Error('Cannot delete the default profile');
+    }
+    const profilePath = getProfilePath(profileName);
+    if (!existsSync(profilePath)) {
+        throw new Error(`Profile "${profileName}" not found`);
+    }
+    // If this is the active profile, switch to default first
+    if (getActiveProfileName() === profileName) {
+        switchProfile('default');
+    }
+    try {
+        unlinkSync(profilePath);
+    }
+    catch (error) {
+        throw new Error(`Failed to delete profile: ${error}`);
+    }
+}
+/**
+ * Rename a profile
+ */
+export function renameProfile(oldName, newName) {
+    ensureProfilesDirectory();
+    // Validate new name
+    if (!newName.trim() || newName.includes('/') || newName.includes('\\')) {
+        throw new Error('Invalid profile name');
+    }
+    if (oldName === newName) {
+        return;
+    }
+    const oldPath = getProfilePath(oldName);
+    const newPath = getProfilePath(newName);
+    if (!existsSync(oldPath)) {
+        throw new Error(`Profile "${oldName}" not found`);
+    }
+    if (existsSync(newPath)) {
+        throw new Error(`Profile "${newName}" already exists`);
+    }
+    try {
+        const config = loadProfile(oldName);
+        if (!config) {
+            throw new Error(`Failed to load profile "${oldName}"`);
+        }
+        // Save with new name
+        saveProfile(newName, config);
+        // Update active profile if necessary
+        if (getActiveProfileName() === oldName) {
+            setActiveProfileName(newName);
+        }
+        // Delete old profile
+        unlinkSync(oldPath);
+    }
+    catch (error) {
+        throw new Error(`Failed to rename profile: ${error}`);
+    }
+}
+/**
+ * Initialize profiles system
+ * This should be called on app startup to ensure profiles are set up
+ */
+export function initializeProfiles() {
+    ensureProfilesDirectory();
+    migrateLegacyConfig();
+    // Ensure the active profile exists and is loaded to config.json
+    const activeProfile = getActiveProfileName();
+    const profileConfig = loadProfile(activeProfile);
+    if (profileConfig) {
+        // Sync the active profile to config.json
+        saveConfig(profileConfig);
+    }
+    else {
+        // If active profile doesn't exist, switch to default
+        switchProfile('default');
+    }
+}

package/dist/utils/contextCompressor.js

@@ -48,8 +48,6 @@ async function compressWithChatCompletions(baseUrl, apiKey, modelName, conversat
         stream: true,
         stream_options: { include_usage: true },
     };
-    // Log request payload
-    console.log('[ContextCompressor] Chat Completions Request:', JSON.stringify(requestPayload, null, 2));
     // Use streaming to avoid timeout
     const stream = (await client.chat.completions.create(requestPayload, {
         headers: customHeaders,
@@ -132,8 +130,6 @@ async function compressWithResponses(baseUrl, apiKey, modelName, conversationMes
         input,
         stream: true,
     };
-    // Log request payload
-    console.log('[ContextCompressor] Responses API Request:', JSON.stringify(requestPayload, null, 2));
     // Use streaming to avoid timeout
     const stream = await client.responses.create(requestPayload, {
         headers: customHeaders,
@@ -229,8 +225,6 @@ async function compressWithGemini(baseUrl, apiKey, modelName, conversationMessag
         systemInstruction,
         contents,
     };
-    // Log request payload
-    console.log('[ContextCompressor] Gemini Request:', JSON.stringify(requestConfig, null, 2));
     // Use streaming to avoid timeout
     const stream = await client.models.generateContentStream(requestConfig);
     let summary = '';
@@ -305,8 +299,6 @@ async function compressWithAnthropic(baseUrl, apiKey, modelName, conversationMes
         system: systemParam,
         messages,
     };
-    // Log request payload
-    console.log('[ContextCompressor] Anthropic Request:', JSON.stringify(requestPayload, null, 2));
     // Use streaming to avoid timeout
     const stream = await client.messages.stream(requestPayload);
     let summary = '';

package/dist/utils/escapeHandler.d.ts

@@ -0,0 +1,79 @@
+/**
+ * Escape Handler Utility
+ * Handles escape sequence issues in AI-generated content
+ * Based on Gemini CLI's approach to handle common LLM escaping bugs
+ */
+/**
+ * Unescapes a string that might have been overly escaped by an LLM.
+ * Common issues:
+ * - "\\n" should be "\n" (newline)
+ * - "\\t" should be "\t" (tab)
+ * - "\\`" should be "`" (backtick)
+ * - "\\\\" should be "\\" (single backslash)
+ * - "\\"Hello\\"" should be "\"Hello\"" (quotes)
+ *
+ * @param inputString - The potentially over-escaped string from AI
+ * @returns The unescaped string
+ *
+ * @example
+ * unescapeString("console.log(\\"Hello\\\\n\\")")
+ * // Returns: console.log("Hello\n")
+ *
+ * unescapeString("const msg = \`Hello \\`\${name}\\`\`")
+ * // Returns: const msg = `Hello `${name}``
+ */
+export declare function unescapeString(inputString: string): string;
+/**
+ * Checks if a string appears to be over-escaped by comparing it with its unescaped version
+ *
+ * @param inputString - The string to check
+ * @returns True if the string contains escape sequences that would be modified by unescapeString
+ *
+ * @example
+ * isOverEscaped("console.log(\\"Hello\\")") // Returns: true
+ * isOverEscaped("console.log(\"Hello\")") // Returns: false
+ */
+export declare function isOverEscaped(inputString: string): boolean;
+/**
+ * Counts occurrences of a substring in a string
+ * Used to verify if unescaping helps find the correct match
+ *
+ * @param str - The string to search in
+ * @param substr - The substring to search for
+ * @returns Number of occurrences found
+ */
+export declare function countOccurrences(str: string, substr: string): number;
+/**
+ * Attempts to fix a search string that doesn't match by trying unescaping
+ * This is a lightweight, non-LLM approach to handle common escaping issues
+ *
+ * @param fileContent - The content of the file to search in
+ * @param searchString - The search string that failed to match
+ * @param expectedOccurrences - Expected number of matches (default: 1)
+ * @returns Object with corrected string and match count, or null if correction didn't help
+ *
+ * @example
+ * const fixed = tryUnescapeFix(fileContent, "console.log(\\"Hello\\")", 1);
+ * if (fixed) {
+ *   // Use fixed.correctedString for the search
+ * }
+ */
+export declare function tryUnescapeFix(fileContent: string, searchString: string, expectedOccurrences?: number): {
+    correctedString: string;
+    occurrences: number;
+} | null;
+/**
+ * Smart trimming that preserves the relationship between paired strings
+ * If trimming the target string results in the expected number of matches,
+ * also trim the paired string to maintain consistency
+ *
+ * @param targetString - The string to potentially trim
+ * @param pairedString - The paired string (e.g., replacement content)
+ * @param fileContent - The file content to search in
+ * @param expectedOccurrences - Expected number of matches
+ * @returns Object with potentially trimmed strings
+ */
+export declare function trimPairIfPossible(targetString: string, pairedString: string, fileContent: string, expectedOccurrences?: number): {
+    target: string;
+    paired: string;
+};

package/dist/utils/escapeHandler.js

@@ -0,0 +1,153 @@
+/**
+ * Escape Handler Utility
+ * Handles escape sequence issues in AI-generated content
+ * Based on Gemini CLI's approach to handle common LLM escaping bugs
+ */
+/**
+ * Unescapes a string that might have been overly escaped by an LLM.
+ * Common issues:
+ * - "\\n" should be "\n" (newline)
+ * - "\\t" should be "\t" (tab)
+ * - "\\`" should be "`" (backtick)
+ * - "\\\\" should be "\\" (single backslash)
+ * - "\\"Hello\\"" should be "\"Hello\"" (quotes)
+ *
+ * @param inputString - The potentially over-escaped string from AI
+ * @returns The unescaped string
+ *
+ * @example
+ * unescapeString("console.log(\\"Hello\\\\n\\")")
+ * // Returns: console.log("Hello\n")
+ *
+ * unescapeString("const msg = \`Hello \\`\${name}\\`\`")
+ * // Returns: const msg = `Hello `${name}``
+ */
+export function unescapeString(inputString) {
+    // Regex explanation:
+    // \\+ : Matches one or more literal backslash characters
+    // (n|t|r|'|"|`|\\|\n) : Capturing group that matches:
+    //   n, t, r : Literal characters for escape sequences
+    //   ', ", ` : Quote characters
+    //   \\ : Literal backslash
+    //   \n : Actual newline character
+    // g : Global flag to replace all occurrences
+    return inputString.replace(/\\+(n|t|r|'|"|`|\\|\n)/g, (match, capturedChar) => {
+        // 'match' is the entire erroneous sequence, e.g., "\\n" or "\\\\`"
+        // 'capturedChar' is the character that determines the true meaning
+        switch (capturedChar) {
+            case 'n':
+                return '\n'; // Newline character
+            case 't':
+                return '\t'; // Tab character
+            case 'r':
+                return '\r'; // Carriage return
+            case "'":
+                return "'"; // Single quote
+            case '"':
+                return '"'; // Double quote
+            case '`':
+                return '`'; // Backtick
+            case '\\':
+                return '\\'; // Single backslash
+            case '\n':
+                return '\n'; // Clean newline (handles "\\\n" cases)
+            default:
+                // Fallback: return original match if unexpected character
+                return match;
+        }
+    });
+}
+/**
+ * Checks if a string appears to be over-escaped by comparing it with its unescaped version
+ *
+ * @param inputString - The string to check
+ * @returns True if the string contains escape sequences that would be modified by unescapeString
+ *
+ * @example
+ * isOverEscaped("console.log(\\"Hello\\")") // Returns: true
+ * isOverEscaped("console.log(\"Hello\")") // Returns: false
+ */
+export function isOverEscaped(inputString) {
+    return unescapeString(inputString) !== inputString;
+}
+/**
+ * Counts occurrences of a substring in a string
+ * Used to verify if unescaping helps find the correct match
+ *
+ * @param str - The string to search in
+ * @param substr - The substring to search for
+ * @returns Number of occurrences found
+ */
+export function countOccurrences(str, substr) {
+    if (substr === '') {
+        return 0;
+    }
+    let count = 0;
+    let pos = str.indexOf(substr);
+    while (pos !== -1) {
+        count++;
+        pos = str.indexOf(substr, pos + substr.length);
+    }
+    return count;
+}
+/**
+ * Attempts to fix a search string that doesn't match by trying unescaping
+ * This is a lightweight, non-LLM approach to handle common escaping issues
+ *
+ * @param fileContent - The content of the file to search in
+ * @param searchString - The search string that failed to match
+ * @param expectedOccurrences - Expected number of matches (default: 1)
+ * @returns Object with corrected string and match count, or null if correction didn't help
+ *
+ * @example
+ * const fixed = tryUnescapeFix(fileContent, "console.log(\\"Hello\\")", 1);
+ * if (fixed) {
+ *   // Use fixed.correctedString for the search
+ * }
+ */
+export function tryUnescapeFix(fileContent, searchString, expectedOccurrences = 1) {
+    // Check if the string appears to be over-escaped
+    if (!isOverEscaped(searchString)) {
+        return null;
+    }
+    // Try unescaping
+    const unescaped = unescapeString(searchString);
+    // Count occurrences with unescaped version
+    const occurrences = countOccurrences(fileContent, unescaped);
+    // Return result if it matches expected occurrences
+    if (occurrences === expectedOccurrences) {
+        return {
+            correctedString: unescaped,
+            occurrences,
+        };
+    }
+    return null;
+}
+/**
+ * Smart trimming that preserves the relationship between paired strings
+ * If trimming the target string results in the expected number of matches,
+ * also trim the paired string to maintain consistency
+ *
+ * @param targetString - The string to potentially trim
+ * @param pairedString - The paired string (e.g., replacement content)
+ * @param fileContent - The file content to search in
+ * @param expectedOccurrences - Expected number of matches
+ * @returns Object with potentially trimmed strings
+ */
+export function trimPairIfPossible(targetString, pairedString, fileContent, expectedOccurrences = 1) {
+    const trimmedTarget = targetString.trim();
+    // If trimming doesn't change the string, return as-is
+    if (targetString.length === trimmedTarget.length) {
+        return { target: targetString, paired: pairedString };
+    }
+    // Check if trimmed version matches expected occurrences
+    const trimmedOccurrences = countOccurrences(fileContent, trimmedTarget);
+    if (trimmedOccurrences === expectedOccurrences) {
+        return {
+            target: trimmedTarget,
+            paired: pairedString.trim(),
+        };
+    }
+    // Trimming didn't help, return original
+    return { target: targetString, paired: pairedString };
+}

package/dist/utils/incrementalSnapshot.js

@@ -1,6 +1,7 @@
 import fs from 'fs/promises';
 import path from 'path';
 import os from 'os';
+import { logger } from '../utils/logger.js';
 /**
  * Incremental Snapshot Manager
  * Only backs up files that are actually modified by tools
@@ -117,7 +118,7 @@ class IncrementalSnapshotManager {
             }
         }
         catch (error) {
-            console.error('Failed to list snapshots:', error);
+            logger.error('Failed to list snapshots:', error);
         }
         return snapshots.sort((a, b) => b.messageIndex - a.messageIndex);
     }

package/dist/utils/mcpToolsManager.js

@@ -7,6 +7,7 @@ import { mcpTools as filesystemTools } from '../mcp/filesystem.js';
 import { mcpTools as terminalTools } from '../mcp/bash.js';
 import { mcpTools as aceCodeSearchTools } from '../mcp/aceCodeSearch.js';
 import { mcpTools as websearchTools } from '../mcp/websearch.js';
+import { mcpTools as ideDiagnosticsTools } from '../mcp/ideDiagnostics.js';
 import { TodoService } from '../mcp/todo.js';
 import { sessionManager } from './sessionManager.js';
 import { logger } from './logger.js';
@@ -177,6 +178,28 @@ async function refreshToolsCache() {
             },
         });
     }
+    // Add built-in IDE Diagnostics tools (always available)
+    const ideDiagnosticsServiceTools = ideDiagnosticsTools.map(tool => ({
+        name: tool.name.replace('ide_', ''),
+        description: tool.description,
+        inputSchema: tool.inputSchema,
+    }));
+    servicesInfo.push({
+        serviceName: 'ide',
+        tools: ideDiagnosticsServiceTools,
+        isBuiltIn: true,
+        connected: true,
+    });
+    for (const tool of ideDiagnosticsTools) {
+        allTools.push({
+            type: 'function',
+            function: {
+                name: `ide-${tool.name.replace('ide_', '')}`,
+                description: tool.description,
+                parameters: tool.inputSchema,
+            },
+        });
+    }
     // Add user-configured MCP server tools (probe for availability but don't maintain connections)
     try {
         const mcpConfig = getMCPConfig();
@@ -519,6 +542,10 @@ export async function executeMCPTool(toolName, args, abortSignal, onTokenUpdate)
         serviceName = 'websearch';
         actualToolName = toolName.substring('websearch-'.length);
     }
+    else if (toolName.startsWith('ide-')) {
+        serviceName = 'ide';
+        actualToolName = toolName.substring('ide-'.length);
+    }
     else {
         // Check configured MCP services
         try {
@@ -625,6 +652,23 @@ export async function executeMCPTool(toolName, args, abortSignal, onTokenUpdate)
                 throw new Error(`Unknown websearch tool: ${actualToolName}`);
         }
     }
+    else if (serviceName === 'ide') {
+        // Handle built-in IDE Diagnostics tools (no connection needed)
+        const { ideDiagnosticsService } = await import('../mcp/ideDiagnostics.js');
+        switch (actualToolName) {
+            case 'get_diagnostics':
+                const diagnostics = await ideDiagnosticsService.getDiagnostics(args.filePath);
+                // Format diagnostics for better readability
+                const formatted = ideDiagnosticsService.formatDiagnostics(diagnostics, args.filePath);
+                return {
+                    diagnostics,
+                    formatted,
+                    summary: `Found ${diagnostics.length} diagnostic(s) in ${args.filePath}`,
+                };
+            default:
+                throw new Error(`Unknown IDE tool: ${actualToolName}`);
+        }
+    }
     else {
         // Handle user-configured MCP service tools - connect only when needed
         const mcpConfig = getMCPConfig();