snow-ai 0.4.16 → 0.4.17

package/dist/utils/fileDialog.js

@@ -1,74 +0,0 @@
-import { exec } from 'child_process';
-import { promisify } from 'util';
-import * as path from 'path';
-import * as os from 'os';
-const execAsync = promisify(exec);
-/**
- * Cross-platform file save dialog
- * Opens a native file save dialog and returns the selected path
- */
-export async function showSaveDialog(defaultFilename = 'export.txt', title = 'Save File') {
-    const platform = os.platform();
-    try {
-        if (platform === 'darwin') {
-            // macOS - use osascript (AppleScript)
-            const defaultPath = path.join(os.homedir(), 'Downloads', defaultFilename);
-            const script = `
-				set defaultPath to POSIX file "${defaultPath}"
-				set saveFile to choose file name with prompt "${title}" default location (POSIX file "${os.homedir()}/Downloads") default name "${defaultFilename}"
-				return POSIX path of saveFile
-			`;
-            const { stdout } = await execAsync(`osascript -e '${script.replace(/'/g, "'\\''")}'`);
-            return stdout.trim();
-        }
-        else if (platform === 'win32') {
-            // Windows - use PowerShell
-            const script = `
-				Add-Type -AssemblyName System.Windows.Forms
-				$dialog = New-Object System.Windows.Forms.SaveFileDialog
-				$dialog.Title = "${title}"
-				$dialog.Filter = "Text files (*.txt)|*.txt|Markdown files (*.md)|*.md|All files (*.*)|*.*"
-				$dialog.FileName = "${defaultFilename}"
-				$dialog.InitialDirectory = "${path.join(os.homedir(), 'Downloads').replace(/\\/g, '\\\\')}"
-				$result = $dialog.ShowDialog()
-				if ($result -eq 'OK') {
-					Write-Output $dialog.FileName
-				}
-			`;
-            const { stdout } = await execAsync(`powershell -NoProfile -Command "${script.replace(/"/g, '\\"')}"`);
-            const result = stdout.trim();
-            return result || null;
-        }
-        else {
-            // Linux - use zenity (most common) or kdialog as fallback
-            try {
-                const defaultPath = path.join(os.homedir(), 'Downloads', defaultFilename);
-                const { stdout } = await execAsync(`zenity --file-selection --save --title="${title}" --filename="${defaultPath}" --confirm-overwrite`);
-                return stdout.trim();
-            }
-            catch (error) {
-                // Try kdialog as fallback for KDE systems
-                try {
-                    const defaultPath = path.join(os.homedir(), 'Downloads', defaultFilename);
-                    const { stdout } = await execAsync(`kdialog --getsavefilename "${defaultPath}" "*.*|All Files" --title "${title}"`);
-                    return stdout.trim();
-                }
-                catch {
-                    // If both fail, return null
-                    return null;
-                }
-            }
-        }
-    }
-    catch (error) {
-        // User cancelled or error occurred
-        return null;
-    }
-}
-/**
- * Check if native file dialogs are available on this platform
- */
-export function isFileDialogSupported() {
-    const platform = os.platform();
-    return platform === 'darwin' || platform === 'win32' || platform === 'linux';
-}

package/dist/utils/fileUtils.d.ts

@@ -1,40 +0,0 @@
-export interface SelectedFile {
-    path: string;
-    lineCount: number;
-    exists: boolean;
-    isImage?: boolean;
-    imageData?: string;
-    mimeType?: string;
-}
-/**
- * Get line count for a file
- */
-export declare function getFileLineCount(filePath: string): Promise<number>;
-/**
- * Get file information including line count
- */
-export declare function getFileInfo(filePath: string): Promise<SelectedFile>;
-/**
- * Format file tree display for messages
- */
-export declare function formatFileTree(files: SelectedFile[]): string;
-/**
- * Parse @file references from message content and check if they exist
- * Also supports direct file paths (pasted from VSCode drag & drop)
- */
-export declare function parseAndValidateFileReferences(content: string): Promise<{
-    cleanContent: string;
-    validFiles: SelectedFile[];
-}>;
-/**
- * Create message with file read instructions for AI
- */
-export declare function createMessageWithFileInstructions(content: string, files: SelectedFile[], editorContext?: {
-    activeFile?: string;
-    selectedText?: string;
-    cursorPosition?: {
-        line: number;
-        character: number;
-    };
-    workspaceFolder?: string;
-}): string;

package/dist/utils/fileUtils.js

@@ -1,185 +0,0 @@
-import fs from 'fs';
-import path from 'path';
-/**
- * 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, editorContext) {
-    const parts = [content];
-    // Add editor context if provided (from VSCode connection)
-    if (editorContext) {
-        const editorLines = [];
-        if (editorContext.workspaceFolder) {
-            editorLines.push(`└─ VSCode Workspace: ${editorContext.workspaceFolder}`);
-        }
-        if (editorContext.activeFile) {
-            editorLines.push(`└─ Active File: ${editorContext.activeFile}`);
-        }
-        if (editorContext.cursorPosition) {
-            editorLines.push(`└─ Cursor: Line ${editorContext.cursorPosition.line + 1}, Column ${editorContext.cursorPosition.character + 1}`);
-        }
-        if (editorContext.selectedText) {
-            editorLines.push(`└─ Selected Code:\n\`\`\`\n${editorContext.selectedText}\n\`\`\``);
-        }
-        if (editorLines.length > 0) {
-            parts.push(editorLines.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');
-}

package/dist/utils/historyManager.d.ts

@@ -1,45 +0,0 @@
-export interface HistoryEntry {
-    content: string;
-    timestamp: number;
-}
-export interface HistoryData {
-    entries: HistoryEntry[];
-    lastCleanup: number;
-}
-declare class HistoryManager {
-    private readonly historyFile;
-    private readonly maxAge;
-    private readonly maxEntries;
-    private historyData;
-    constructor();
-    /**
-     * Ensure the .snow directory exists
-     */
-    private ensureSnowDir;
-    /**
-     * Load history from file
-     */
-    loadHistory(): Promise<HistoryEntry[]>;
-    /**
-     * Add a new entry to history
-     */
-    addEntry(content: string): Promise<void>;
-    /**
-     * Get all history entries (newest first)
-     */
-    getEntries(): Promise<HistoryEntry[]>;
-    /**
-     * Clean up entries older than maxAge
-     */
-    private cleanupOldEntries;
-    /**
-     * Save history to file
-     */
-    private saveHistory;
-    /**
-     * Clear all history
-     */
-    clearHistory(): Promise<void>;
-}
-export declare const historyManager: HistoryManager;
-export {};

package/dist/utils/historyManager.js

@@ -1,159 +0,0 @@
-import fs from 'fs/promises';
-import path from 'path';
-import os from 'os';
-import { logger } from './logger.js';
-class HistoryManager {
-    constructor() {
-        Object.defineProperty(this, "historyFile", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "maxAge", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: 24 * 60 * 60 * 1000
-        }); // 1 day in milliseconds
-        Object.defineProperty(this, "maxEntries", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: 1000
-        }); // Maximum number of entries to keep
-        Object.defineProperty(this, "historyData", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: null
-        });
-        const snowDir = path.join(os.homedir(), '.snow');
-        this.historyFile = path.join(snowDir, 'history.json');
-    }
-    /**
-     * Ensure the .snow directory exists
-     */
-    async ensureSnowDir() {
-        try {
-            const snowDir = path.dirname(this.historyFile);
-            await fs.mkdir(snowDir, { recursive: true });
-        }
-        catch (error) {
-            // Directory already exists or other error
-        }
-    }
-    /**
-     * Load history from file
-     */
-    async loadHistory() {
-        try {
-            await this.ensureSnowDir();
-            // Try to read existing history file
-            const data = await fs.readFile(this.historyFile, 'utf-8');
-            this.historyData = JSON.parse(data);
-            // Clean up old entries if needed
-            await this.cleanupOldEntries();
-            return this.historyData.entries;
-        }
-        catch (error) {
-            // File doesn't exist or is corrupted, start fresh
-            this.historyData = {
-                entries: [],
-                lastCleanup: Date.now(),
-            };
-            return [];
-        }
-    }
-    /**
-     * Add a new entry to history
-     */
-    async addEntry(content) {
-        // Don't add empty or whitespace-only entries
-        if (!content || !content.trim()) {
-            return;
-        }
-        // Load history if not already loaded
-        if (!this.historyData) {
-            await this.loadHistory();
-        }
-        // Don't add duplicate of the last entry
-        const lastEntry = this.historyData.entries[this.historyData.entries.length - 1];
-        if (lastEntry && lastEntry.content === content) {
-            return;
-        }
-        // Add new entry
-        const newEntry = {
-            content,
-            timestamp: Date.now(),
-        };
-        this.historyData.entries.push(newEntry);
-        // Limit the number of entries
-        if (this.historyData.entries.length > this.maxEntries) {
-            this.historyData.entries = this.historyData.entries.slice(-this.maxEntries);
-        }
-        // Save to file
-        await this.saveHistory();
-    }
-    /**
-     * Get all history entries (newest first)
-     */
-    async getEntries() {
-        if (!this.historyData) {
-            await this.loadHistory();
-        }
-        // Return a copy in reverse order (newest first)
-        return [...this.historyData.entries].reverse();
-    }
-    /**
-     * Clean up entries older than maxAge
-     */
-    async cleanupOldEntries() {
-        if (!this.historyData) {
-            return;
-        }
-        const now = Date.now();
-        const cutoffTime = now - this.maxAge;
-        // Only cleanup once per hour to avoid excessive file writes
-        if (now - this.historyData.lastCleanup < 60 * 60 * 1000) {
-            return;
-        }
-        // Filter out old entries
-        const originalLength = this.historyData.entries.length;
-        this.historyData.entries = this.historyData.entries.filter(entry => entry.timestamp > cutoffTime);
-        // Update last cleanup time
-        this.historyData.lastCleanup = now;
-        // Save if we removed any entries
-        if (this.historyData.entries.length < originalLength) {
-            await this.saveHistory();
-            logger.debug(`Cleaned up ${originalLength - this.historyData.entries.length} old history entries`);
-        }
-    }
-    /**
-     * Save history to file
-     */
-    async saveHistory() {
-        if (!this.historyData) {
-            return;
-        }
-        try {
-            await this.ensureSnowDir();
-            await fs.writeFile(this.historyFile, JSON.stringify(this.historyData, null, 2), 'utf-8');
-        }
-        catch (error) {
-            logger.error('Failed to save history:', error);
-        }
-    }
-    /**
-     * Clear all history
-     */
-    async clearHistory() {
-        this.historyData = {
-            entries: [],
-            lastCleanup: Date.now(),
-        };
-        await this.saveHistory();
-    }
-}
-// Export singleton instance
-export const historyManager = new HistoryManager();

package/dist/utils/incrementalSnapshot.d.ts

@@ -1,109 +0,0 @@
-/**
- * File backup entry
- */
-interface FileBackup {
-    path: string;
-    content: string | null;
-    existed: boolean;
-}
-/**
- * Snapshot metadata
- */
-interface SnapshotMetadata {
-    sessionId: string;
-    messageIndex: number;
-    timestamp: number;
-    backups: FileBackup[];
-}
-/**
- * Incremental Snapshot Manager
- * Only backs up files that are actually modified by tools
- */
-declare class IncrementalSnapshotManager {
-    private readonly snapshotsDir;
-    private activeSnapshot;
-    constructor();
-    /**
-     * Ensure snapshots directory exists
-     */
-    private ensureSnapshotsDir;
-    /**
-     * Get snapshot file path
-     */
-    private getSnapshotPath;
-    /**
-     * Create a new snapshot for a message
-     */
-    createSnapshot(sessionId: string, messageIndex: number): Promise<void>;
-    /**
-     * Backup a file before modification
-     * Call this BEFORE modifying the file
-     */
-    backupFile(filePath: string): Promise<void>;
-    /**
-     * Save current snapshot to disk
-     */
-    private saveSnapshot;
-    /**
-     * Commit snapshot (called after message completes successfully)
-     */
-    commitSnapshot(): Promise<void>;
-    /**
-     * List all snapshots for a session
-     */
-    listSnapshots(sessionId: string): Promise<Array<{
-        messageIndex: number;
-        timestamp: number;
-        fileCount: number;
-    }>>;
-    /**
-     * Rollback to a specific snapshot
-     */
-    rollbackToSnapshot(sessionId: string, messageIndex: number): Promise<boolean>;
-    /**
-     * Get list of files that will be affected by rollback to a specific message index
-     * @param sessionId Session ID
-     * @param targetMessageIndex The message index to rollback to (inclusive)
-     * @returns Array of file paths that will be rolled back
-     */
-    getFilesToRollback(sessionId: string, targetMessageIndex: number): Promise<string[]>;
-    /**
-     * Rollback all snapshots after a specific message index
-     * This is used when user selects to rollback to a specific message
-     * @param sessionId Session ID
-     * @param targetMessageIndex The message index to rollback to (inclusive)
-     * @returns Number of files rolled back
-     */
-    rollbackToMessageIndex(sessionId: string, targetMessageIndex: number): Promise<number>;
-    /**
-     * Delete all snapshots >= targetMessageIndex
-     * This is used when user rolls back conversation to clean up snapshot files
-     * @param sessionId Session ID
-     * @param targetMessageIndex The message index to delete from (inclusive)
-     */
-    deleteSnapshotsFromIndex(sessionId: string, targetMessageIndex: number): Promise<number>;
-    /**
-     * Clear all snapshots for a session
-     */
-    clearAllSnapshots(sessionId: string): Promise<void>;
-    /**
-     * Get active snapshot
-     */
-    getActiveSnapshot(): SnapshotMetadata | null;
-    /**
-     * Capture workspace state before terminal command
-     */
-    captureWorkspaceState(workspaceRoot?: string): Promise<Map<string, {
-        mtime: number;
-        size: number;
-    }>>;
-    /**
-     * Detect and backup changed files after terminal command
-     */
-    backupChangedFiles(beforeState: Map<string, {
-        mtime: number;
-        size: number;
-    }>, workspaceRoot?: string): Promise<void>;
-}
-export declare const incrementalSnapshotManager: IncrementalSnapshotManager;
-export {};