wave-code 0.0.2

package/dist/utils/clipboard.js

@@ -0,0 +1,347 @@
+import { unlinkSync, existsSync } from "fs";
+import { join } from "path";
+import { tmpdir } from "os";
+/**
+ * Read image from clipboard
+ * @returns Promise<ClipboardImageResult> Result containing image path or error information
+ */
+export async function readClipboardImage() {
+    try {
+        const platform = process.platform;
+        if (platform === "darwin") {
+            return await readClipboardImageMac();
+        }
+        else if (platform === "win32") {
+            return await readClipboardImageWindows();
+        }
+        else if (platform === "linux") {
+            return await readClipboardImageLinux();
+        }
+        else {
+            return {
+                success: false,
+                error: `Clipboard image reading is not supported on platform: ${platform}`,
+            };
+        }
+    }
+    catch (error) {
+        return {
+            success: false,
+            error: `Failed to read clipboard image: ${error instanceof Error ? error.message : String(error)}`,
+        };
+    }
+}
+/**
+ * Read clipboard image on macOS
+ */
+async function readClipboardImageMac() {
+    const { exec } = await import("child_process");
+    const { promisify } = await import("util");
+    const execAsync = promisify(exec);
+    try {
+        // Try to read image data directly to check if image exists
+        const testScript = `
+      tell application "System Events"
+        try
+          set imageData to the clipboard as «class PNGf»
+          return true
+        on error
+          return false
+        end try
+      end tell
+    `;
+        let hasImage = false;
+        try {
+            const { stdout: testResult } = await execAsync(`osascript -e '${testScript}'`);
+            hasImage = testResult.trim() === "true";
+        }
+        catch {
+            hasImage = false;
+        }
+        if (!hasImage) {
+            return {
+                success: false,
+                error: "No image found in clipboard",
+            };
+        }
+        // Generate temporary file path
+        const tempFilePath = join(tmpdir(), `clipboard-image-${Date.now()}.png`);
+        // Use osascript to save clipboard image as file
+        const saveScript = `
+      tell application "System Events"
+        try
+          set imageData to the clipboard as «class PNGf»
+          set fileRef to open for access POSIX file "${tempFilePath}" with write permission
+          write imageData to fileRef
+          close access fileRef
+          return true
+        on error errMsg
+          try
+            close access fileRef
+          end try
+          error errMsg
+        end try
+      end tell
+    `;
+        await execAsync(`osascript -e '${saveScript}'`);
+        // Verify if file was created successfully
+        if (!existsSync(tempFilePath)) {
+            return {
+                success: false,
+                error: "Failed to save clipboard image to temporary file",
+            };
+        }
+        return {
+            success: true,
+            imagePath: tempFilePath,
+            mimeType: "image/png",
+        };
+    }
+    catch (error) {
+        return {
+            success: false,
+            error: `Failed to read clipboard image on macOS: ${error instanceof Error ? error.message : String(error)}`,
+        };
+    }
+}
+/**
+ * Read clipboard image on Windows
+ */
+async function readClipboardImageWindows() {
+    try {
+        const { exec } = await import("child_process");
+        const { promisify } = await import("util");
+        const execAsync = promisify(exec);
+        // Use PowerShell to check if clipboard contains image
+        const checkScript = `
+      Add-Type -AssemblyName System.Windows.Forms
+      if ([System.Windows.Forms.Clipboard]::ContainsImage()) {
+        Write-Output "true"
+      } else {
+        Write-Output "false"
+      }
+    `;
+        try {
+            const { stdout } = await execAsync(`powershell -Command "${checkScript}"`);
+            const hasImage = stdout.trim() === "true";
+            if (!hasImage) {
+                return {
+                    success: false,
+                    error: "No image found in clipboard",
+                };
+            }
+            // Generate temporary file path
+            const tempFilePath = join(tmpdir(), `clipboard-image-${Date.now()}.png`);
+            // Use PowerShell to save clipboard image
+            const saveScript = `
+        Add-Type -AssemblyName System.Windows.Forms
+        Add-Type -AssemblyName System.Drawing
+        $image = [System.Windows.Forms.Clipboard]::GetImage()
+        if ($image -ne $null) {
+          $image.Save("${tempFilePath.replace(/\\/g, "\\\\")}", [System.Drawing.Imaging.ImageFormat]::Png)
+          Write-Output "true"
+        } else {
+          Write-Output "false"
+        }
+      `;
+            const { stdout: saveResult } = await execAsync(`powershell -Command "${saveScript}"`);
+            if (saveResult.trim() !== "true" || !existsSync(tempFilePath)) {
+                return {
+                    success: false,
+                    error: "Failed to save clipboard image to temporary file",
+                };
+            }
+            return {
+                success: true,
+                imagePath: tempFilePath,
+                mimeType: "image/png",
+            };
+        }
+        catch (err) {
+            return {
+                success: false,
+                error: `Failed to access clipboard on Windows: ${err instanceof Error ? err.message : String(err)}`,
+            };
+        }
+    }
+    catch (err) {
+        return {
+            success: false,
+            error: `Failed to read clipboard image on Windows: ${err instanceof Error ? err.message : String(err)}`,
+        };
+    }
+}
+/**
+ * Read clipboard image on Linux
+ */
+async function readClipboardImageLinux() {
+    try {
+        // Linux can use tools like xclip or wl-clipboard
+        const { exec } = await import("child_process");
+        const { promisify } = await import("util");
+        const execAsync = promisify(exec);
+        // Check if xclip is available
+        try {
+            await execAsync("which xclip");
+        }
+        catch {
+            return {
+                success: false,
+                error: "xclip is required for clipboard image operations on Linux. Please install it: sudo apt-get install xclip",
+            };
+        }
+        // Check if clipboard contains image
+        try {
+            await execAsync("xclip -selection clipboard -t image/png -o > /dev/null 2>&1");
+        }
+        catch {
+            return {
+                success: false,
+                error: "No image found in clipboard",
+            };
+        }
+        // Generate temporary file path
+        const tempFilePath = join(tmpdir(), `clipboard-image-${Date.now()}.png`);
+        // Use xclip to save clipboard image
+        try {
+            await execAsync(`xclip -selection clipboard -t image/png -o > "${tempFilePath}"`);
+            if (!existsSync(tempFilePath)) {
+                return {
+                    success: false,
+                    error: "Failed to save clipboard image to temporary file",
+                };
+            }
+            return {
+                success: true,
+                imagePath: tempFilePath,
+                mimeType: "image/png",
+            };
+        }
+        catch (err) {
+            return {
+                success: false,
+                error: `Failed to save clipboard image: ${err instanceof Error ? err.message : String(err)}`,
+            };
+        }
+    }
+    catch (err) {
+        return {
+            success: false,
+            error: `Failed to read clipboard image on Linux: ${err instanceof Error ? err.message : String(err)}`,
+        };
+    }
+}
+/**
+ * Clean up temporary image file
+ * @param imagePath Path to the image file to clean up
+ */
+export function cleanupTempImage(imagePath) {
+    try {
+        if (existsSync(imagePath)) {
+            unlinkSync(imagePath);
+        }
+    }
+    catch (error) {
+        console.warn(`Failed to cleanup temporary image file: ${imagePath}`, error);
+    }
+}
+/**
+ * Check if clipboard contains image (quick check, does not save file)
+ * @returns Promise<boolean> Whether it contains image
+ */
+export async function hasClipboardImage() {
+    try {
+        const platform = process.platform;
+        if (platform === "darwin") {
+            return await hasClipboardImageMac();
+        }
+        else if (platform === "win32") {
+            return await hasClipboardImageWindows();
+        }
+        else if (platform === "linux") {
+            return await hasClipboardImageLinux();
+        }
+        else {
+            return false;
+        }
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Check if clipboard contains image on macOS
+ */
+async function hasClipboardImageMac() {
+    try {
+        const { exec } = await import("child_process");
+        const { promisify } = await import("util");
+        const execAsync = promisify(exec);
+        const checkScript = `
+      tell application "System Events"
+        try
+          set imageData to the clipboard as «class PNGf»
+          return true
+        on error
+          return false
+        end try
+      end tell
+    `;
+        const { stdout } = await execAsync(`osascript -e '${checkScript}'`);
+        return stdout.trim() === "true";
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Check if clipboard contains image on Windows
+ */
+async function hasClipboardImageWindows() {
+    try {
+        const { exec } = await import("child_process");
+        const { promisify } = await import("util");
+        const execAsync = promisify(exec);
+        const checkScript = `
+      Add-Type -AssemblyName System.Windows.Forms
+      if ([System.Windows.Forms.Clipboard]::ContainsImage()) {
+        Write-Output "true"
+      } else {
+        Write-Output "false"
+      }
+    `;
+        const { stdout } = await execAsync(`powershell -Command "${checkScript}"`);
+        return stdout.trim() === "true";
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Check if clipboard contains image on Linux
+ */
+async function hasClipboardImageLinux() {
+    try {
+        const { exec } = await import("child_process");
+        const { promisify } = await import("util");
+        const execAsync = promisify(exec);
+        // Check if xclip is available
+        try {
+            await execAsync("which xclip");
+        }
+        catch {
+            return false;
+        }
+        // Check if clipboard contains image
+        try {
+            await execAsync("xclip -selection clipboard -t image/png -o > /dev/null 2>&1");
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    catch {
+        return false;
+    }
+}

package/dist/utils/constants.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Application constants definition
+ */
+/**
+ * Application data storage directory
+ * Used to store debug logs, command history and other data
+ */
+export declare const DATA_DIRECTORY: string;
+/**
+ * Application log file path
+ */
+export declare const LOG_FILE: string;
+/**
+ * Pagination related constants
+ */
+export declare const MESSAGES_PER_PAGE = 20;
+//# sourceMappingURL=constants.d.ts.map

package/dist/utils/constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../src/utils/constants.ts"],"names":[],"mappings":"AAAA;;GAEG;AAKH;;;GAGG;AACH,eAAO,MAAM,cAAc,QAAmC,CAAC;AAE/D;;GAEG;AACH,eAAO,MAAM,QAAQ,QAAuC,CAAC;AAE7D;;GAEG;AACH,eAAO,MAAM,iBAAiB,KAAK,CAAC"}

package/dist/utils/constants.js

@@ -0,0 +1,18 @@
+/**
+ * Application constants definition
+ */
+import path from "path";
+import os from "os";
+/**
+ * Application data storage directory
+ * Used to store debug logs, command history and other data
+ */
+export const DATA_DIRECTORY = path.join(os.homedir(), ".wave");
+/**
+ * Application log file path
+ */
+export const LOG_FILE = path.join(DATA_DIRECTORY, "app.log");
+/**
+ * Pagination related constants
+ */
+export const MESSAGES_PER_PAGE = 20; // Number of messages displayed per page

package/dist/utils/logger.d.ts

@@ -0,0 +1,72 @@
+/**
+ * Logger utility module
+ * Supports filtering by log level and keywords
+ * Logs are written to files instead of terminal to avoid being cleared by Ink app
+ *
+ * Performance optimization:
+ * - In test environment, you can disable all file and console I/O operations by setting environment variable DISABLE_LOGGER_IO=true
+ * - This can significantly improve test execution performance by avoiding unnecessary disk writes
+ */
+/**
+ * Log level enumeration
+ */
+export declare enum LogLevel {
+    DEBUG = 0,
+    INFO = 1,
+    WARN = 2,
+    ERROR = 3
+}
+/**
+ * Log configuration interface
+ */
+interface LogConfig {
+    readonly level: LogLevel;
+    readonly keywords: string[];
+}
+/**
+ * Logger object
+ */
+export declare const logger: {
+    /**
+     * Debug log output function
+     */
+    debug: (...args: unknown[]) => void;
+    /**
+     * Info log output function
+     */
+    info: (...args: unknown[]) => void;
+    /**
+     * Warning log output function
+     */
+    warn: (...args: unknown[]) => void;
+    /**
+     * Error log output function
+     */
+    error: (...args: unknown[]) => void;
+};
+/**
+ * Get current log configuration
+ */
+export declare const getLogConfig: () => LogConfig;
+/**
+ * Get log file path
+ */
+export declare const getLogFile: () => string;
+/**
+ * Log cleanup configuration
+ */
+interface LogCleanupConfig {
+    /** Maximum size of current log file (bytes), default 10MB */
+    maxFileSize: number;
+    /** Number of lines to keep when truncating, default 1000 lines */
+    keepLines: number;
+}
+/**
+ * Execute log cleanup
+ * Truncate current log file (if needed)
+ *
+ * @param customConfig Custom cleanup configuration, if not provided uses default configuration
+ */
+export declare const cleanupLogs: (customConfig?: Partial<LogCleanupConfig>) => Promise<void>;
+export {};
+//# sourceMappingURL=logger.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"logger.d.ts","sourceRoot":"","sources":["../../src/utils/logger.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAOH;;GAEG;AACH,oBAAY,QAAQ;IAClB,KAAK,IAAI;IACT,IAAI,IAAI;IACR,IAAI,IAAI;IACR,KAAK,IAAI;CACV;AAYD;;GAEG;AACH,UAAU,SAAS;IACjB,QAAQ,CAAC,KAAK,EAAE,QAAQ,CAAC;IACzB,QAAQ,CAAC,QAAQ,EAAE,MAAM,EAAE,CAAC;CAC7B;AA8HD;;GAEG;AACH,eAAO,MAAM,MAAM;IACjB;;OAEG;qBACc,OAAO,EAAE,KAAG,IAAI;IAIjC;;OAEG;oBACa,OAAO,EAAE,KAAG,IAAI;IAIhC;;OAEG;oBACa,OAAO,EAAE,KAAG,IAAI;IAIhC;;OAEG;qBACc,OAAO,EAAE,KAAG,IAAI;CAGlC,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,YAAY,QAAO,SAE/B,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,UAAU,QAAO,MAE7B,CAAC;AAEF;;GAEG;AACH,UAAU,gBAAgB;IACxB,6DAA6D;IAC7D,WAAW,EAAE,MAAM,CAAC;IACpB,kEAAkE;IAClE,SAAS,EAAE,MAAM,CAAC;CACnB;AAqDD;;;;;GAKG;AACH,eAAO,MAAM,WAAW,GACtB,eAAe,OAAO,CAAC,gBAAgB,CAAC,KACvC,OAAO,CAAC,IAAI,CAiBd,CAAC"}

package/dist/utils/logger.js

@@ -0,0 +1,245 @@
+/**
+ * Logger utility module
+ * Supports filtering by log level and keywords
+ * Logs are written to files instead of terminal to avoid being cleared by Ink app
+ *
+ * Performance optimization:
+ * - In test environment, you can disable all file and console I/O operations by setting environment variable DISABLE_LOGGER_IO=true
+ * - This can significantly improve test execution performance by avoiding unnecessary disk writes
+ */
+import * as fs from "fs";
+import { LOG_FILE, DATA_DIRECTORY } from "./constants.js";
+const logFile = process.env.LOG_FILE || LOG_FILE;
+/**
+ * Log level enumeration
+ */
+export var LogLevel;
+(function (LogLevel) {
+    LogLevel[LogLevel["DEBUG"] = 0] = "DEBUG";
+    LogLevel[LogLevel["INFO"] = 1] = "INFO";
+    LogLevel[LogLevel["WARN"] = 2] = "WARN";
+    LogLevel[LogLevel["ERROR"] = 3] = "ERROR";
+})(LogLevel || (LogLevel = {}));
+/**
+ * Log level name mapping
+ */
+const LOG_LEVEL_NAMES = {
+    [LogLevel.DEBUG]: "DEBUG",
+    [LogLevel.INFO]: "INFO",
+    [LogLevel.WARN]: "WARN",
+    [LogLevel.ERROR]: "ERROR",
+};
+/**
+ * Parse log level from environment variable
+ */
+const parseLogLevel = (levelStr) => {
+    if (!levelStr)
+        return LogLevel.INFO;
+    const upperLevel = levelStr.toUpperCase();
+    switch (upperLevel) {
+        case "DEBUG":
+            return LogLevel.DEBUG;
+        case "INFO":
+            return LogLevel.INFO;
+        case "WARN":
+            return LogLevel.WARN;
+        case "ERROR":
+            return LogLevel.ERROR;
+        default:
+            return LogLevel.INFO;
+    }
+};
+/**
+ * Parse keyword filter from environment variable
+ */
+const parseKeywords = (keywordsStr) => {
+    if (!keywordsStr)
+        return [];
+    return keywordsStr
+        .split(",")
+        .map((k) => k.trim().toLowerCase())
+        .filter((k) => k.length > 0);
+};
+/**
+ * Load log configuration from environment variables
+ *
+ * Supported environment variables:
+ * - LOG_LEVEL: Log level (DEBUG, INFO, WARN, ERROR), default INFO
+ * - LOG_KEYWORDS: Keyword filter, comma-separated, default no filter
+ */
+const logConfig = {
+    level: parseLogLevel(process.env.LOG_LEVEL),
+    keywords: parseKeywords(process.env.LOG_KEYWORDS),
+};
+/**
+ * Check if log should be recorded
+ */
+const shouldLog = (level, message) => {
+    // Check log level
+    if (level < logConfig.level) {
+        return false;
+    }
+    // If no keyword filter is set, record all logs that meet the level requirement
+    if (logConfig.keywords.length === 0) {
+        return true;
+    }
+    // Check keyword filter
+    const lowerMessage = message.toLowerCase();
+    return logConfig.keywords.some((keyword) => lowerMessage.includes(keyword));
+};
+/**
+ * Format log arguments
+ */
+const formatArg = (arg) => {
+    if (arg === null)
+        return "null";
+    if (arg === undefined)
+        return "undefined";
+    if (arg instanceof Error) {
+        // Special handling for Error objects, display stack or message
+        return arg.stack || arg.message || String(arg);
+    }
+    if (typeof arg === "object") {
+        try {
+            return JSON.stringify(arg, null, 2);
+        }
+        catch {
+            // If JSON.stringify fails, fallback to String()
+            return String(arg);
+        }
+    }
+    return String(arg);
+};
+/**
+ * Generic log output function
+ */
+const logMessage = (level, ...args) => {
+    const messageText = args.map(formatArg).join(" ");
+    // Check if this log should be recorded
+    if (!shouldLog(level, messageText)) {
+        return;
+    }
+    // If logger I/O operations are disabled, return directly to save performance
+    if (process.env.DISABLE_LOGGER_IO === "true") {
+        return;
+    }
+    const levelName = LOG_LEVEL_NAMES[level];
+    const timestamp = new Date().toISOString();
+    const formattedMessage = `[${timestamp}] [${levelName}] ${messageText}\n`;
+    try {
+        // Ensure directory exists
+        if (!fs.existsSync(DATA_DIRECTORY)) {
+            fs.mkdirSync(DATA_DIRECTORY, { recursive: true });
+        }
+        // Write log to file
+        fs.appendFileSync(logFile, formattedMessage);
+    }
+    catch (error) {
+        // If file write fails, fallback to stderr
+        process.stderr.write(`[${levelName}] Failed to write to log file: ${error}\n`);
+        process.stderr.write(formattedMessage);
+    }
+};
+/**
+ * Logger object
+ */
+export const logger = {
+    /**
+     * Debug log output function
+     */
+    debug: (...args) => {
+        logMessage(LogLevel.DEBUG, ...args);
+    },
+    /**
+     * Info log output function
+     */
+    info: (...args) => {
+        logMessage(LogLevel.INFO, ...args);
+    },
+    /**
+     * Warning log output function
+     */
+    warn: (...args) => {
+        logMessage(LogLevel.WARN, ...args);
+    },
+    /**
+     * Error log output function
+     */
+    error: (...args) => {
+        logMessage(LogLevel.ERROR, ...args);
+    },
+};
+/**
+ * Get current log configuration
+ */
+export const getLogConfig = () => {
+    return logConfig;
+};
+/**
+ * Get log file path
+ */
+export const getLogFile = () => {
+    return logFile;
+};
+/**
+ * Get log cleanup configuration
+ * Can override default configuration with environment variables
+ */
+const getCleanupConfig = () => {
+    return {
+        maxFileSize: parseInt(process.env.LOG_MAX_FILE_SIZE || "10485760", 10), // 10MB
+        keepLines: parseInt(process.env.LOG_KEEP_LINES || "1000", 10),
+    };
+};
+/**
+ * Truncate current log file if too large
+ * Keep the last specified number of lines
+ */
+const truncateLogFileIfNeeded = (config) => {
+    // If logger I/O operations are disabled, return directly to save performance
+    if (process.env.DISABLE_LOGGER_IO === "true") {
+        return;
+    }
+    try {
+        if (!fs.existsSync(logFile)) {
+            return;
+        }
+        const stats = fs.statSync(logFile);
+        // If file size exceeds limit, truncate file
+        if (stats.size > config.maxFileSize) {
+            const content = fs.readFileSync(logFile, "utf8");
+            const lines = content.split("\n");
+            // Keep the last specified number of lines
+            const keepLines = Math.min(config.keepLines, lines.length);
+            const truncatedContent = lines.slice(-keepLines).join("\n");
+            // Write truncated content
+            fs.writeFileSync(logFile, truncatedContent);
+            // Record truncation operation
+            const removedLines = lines.length - keepLines;
+            logger.info(`Log file truncated: removed ${removedLines} lines, kept last ${keepLines} lines`);
+        }
+    }
+    catch (error) {
+        logger.warn("Failed to truncate log file:", error);
+    }
+};
+/**
+ * Execute log cleanup
+ * Truncate current log file (if needed)
+ *
+ * @param customConfig Custom cleanup configuration, if not provided uses default configuration
+ */
+export const cleanupLogs = async (customConfig) => {
+    // If logger I/O operations are disabled, return directly to save performance
+    if (process.env.DISABLE_LOGGER_IO === "true") {
+        return;
+    }
+    const config = { ...getCleanupConfig(), ...customConfig };
+    logger.info("Starting log cleanup...", {
+        maxFileSize: config.maxFileSize,
+        keepLines: config.keepLines,
+    });
+    // Truncate current log file (if needed)
+    truncateLogFileIfNeeded(config);
+    logger.info("Log cleanup completed");
+};