wave-code 1.0.9 → 1.1.0

package/dist/utils/bracketedPaste.js

@@ -1,122 +0,0 @@
-const ESC = "\u001b";
-const START_STRIPPED = "[200~";
-const START_RAW = `${ESC}[200~`;
-const END_STRIPPED = "[201~";
-const END_RAW = `${ESC}[201~`;
-const START_FORMS = [START_RAW, START_STRIPPED];
-const END_FORMS = [END_RAW, END_STRIPPED];
-/**
- * Suffixes that may be the beginning of a marker split across chunks.
- * Longest-first so the longest matching suffix is deferred (e.g. `[200`
- * rather than `[20` for `...x[200`). Deferral is flush-equivalent: if the
- * next chunk does not complete a marker, the deferred suffix is delivered
- * as regular input unchanged.
- */
-const PARTIAL_SUFFIXES = [
-    `${ESC}[201`,
-    `${ESC}[200`,
-    `${ESC}[20`,
-    `${ESC}[2`,
-    "[201",
-    "[200",
-    "[20",
-    "[2",
-].sort((a, b) => b.length - a.length);
-export function createBracketedPasteDetector() {
-    let inPaste = false;
-    let buffer = ""; // paste content collected since the start marker
-    let pending = ""; // deferred partial marker suffix from a previous chunk
-    const findFirst = (text, forms) => {
-        let best = null;
-        for (const form of forms) {
-            const index = text.indexOf(form);
-            if (index !== -1 && (best === null || index < best.index)) {
-                best = { index, length: form.length };
-            }
-        }
-        return best;
-    };
-    const endsWithPartial = (text) => {
-        for (const prefix of PARTIAL_SUFFIXES) {
-            if (text.endsWith(prefix)) {
-                return prefix;
-            }
-        }
-        return null;
-    };
-    const process = (chunk) => {
-        let remaining = pending + chunk;
-        pending = "";
-        let leadingInput = "";
-        let pasteText = null;
-        while (remaining.length > 0) {
-            if (!inPaste) {
-                const start = findFirst(remaining, START_FORMS);
-                if (start) {
-                    leadingInput += remaining.slice(0, start.index);
-                    remaining = remaining.slice(start.index + start.length);
-                    inPaste = true;
-                    continue;
-                }
-                // Orphan end marker (start was missed, e.g. consumed by another
-                // input handler): treat the preceding text as paste so a trailing
-                // `\r` cannot trigger the coalesced-Enter submit heuristic.
-                const end = findFirst(remaining, END_FORMS);
-                if (end) {
-                    pasteText =
-                        (pasteText ?? "") + leadingInput + remaining.slice(0, end.index);
-                    leadingInput = "";
-                    remaining = remaining.slice(end.index + end.length);
-                    continue;
-                }
-                const partial = endsWithPartial(remaining);
-                if (partial) {
-                    pending = remaining.slice(remaining.length - partial.length);
-                    remaining = remaining.slice(0, remaining.length - partial.length);
-                }
-                if (remaining.length > 0) {
-                    leadingInput += remaining;
-                    remaining = "";
-                }
-                break;
-            }
-            const end = findFirst(remaining, END_FORMS);
-            if (end) {
-                pasteText = (pasteText ?? "") + buffer + remaining.slice(0, end.index);
-                buffer = "";
-                inPaste = false;
-                remaining = remaining.slice(end.index + end.length);
-                continue;
-            }
-            const partial = endsWithPartial(remaining);
-            if (partial) {
-                pending = remaining.slice(remaining.length - partial.length);
-                remaining = remaining.slice(0, remaining.length - partial.length);
-            }
-            buffer += remaining;
-            remaining = "";
-            break;
-        }
-        if (inPaste) {
-            // Paste still in flight: hold the content, deliver nothing yet.
-            return { kind: "consume" };
-        }
-        if (pasteText !== null) {
-            const result = {
-                kind: "paste",
-                text: pasteText,
-            };
-            if (leadingInput !== "") {
-                result.leadingInput = leadingInput;
-            }
-            return result;
-        }
-        return { kind: "input", input: leadingInput };
-    };
-    const reset = () => {
-        inPaste = false;
-        buffer = "";
-        pending = "";
-    };
-    return { process, reset };
-}

package/dist/utils/clipboard.d.ts

@@ -1,21 +0,0 @@
-export interface ClipboardImageResult {
-    success: boolean;
-    imagePath?: string;
-    error?: string;
-    mimeType?: string;
-}
-/**
- * Read image from clipboard
- * @returns Promise<ClipboardImageResult> Result containing image path or error information
- */
-export declare function readClipboardImage(): Promise<ClipboardImageResult>;
-/**
- * Clean up temporary image file
- * @param imagePath Path to the image file to clean up
- */
-export declare function cleanupTempImage(imagePath: string): void;
-/**
- * Check if clipboard contains image (quick check, does not save file)
- * @returns Promise<boolean> Whether it contains image
- */
-export declare function hasClipboardImage(): Promise<boolean>;

package/dist/utils/clipboard.js

@@ -1,347 +0,0 @@
-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

@@ -1,16 +0,0 @@
-/**
- * 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 = 15;

package/dist/utils/constants.js

@@ -1,18 +0,0 @@
-/**
- * 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 = 15; // Number of messages displayed per page

package/dist/utils/highlightUtils.d.ts

@@ -1 +0,0 @@
-export declare function highlightToAnsi(code: string, language?: string): string;

package/dist/utils/highlightUtils.js

@@ -1,93 +0,0 @@
-import hljs from "highlight.js";
-import { parse, HTMLElement, TextNode } from "node-html-parser";
-import chalk from "chalk";
-const theme = {
-    "hljs-keyword": chalk.blue,
-    "hljs-built_in": chalk.cyan,
-    "hljs-type": chalk.cyan,
-    "hljs-literal": chalk.magenta,
-    "hljs-number": chalk.magenta,
-    "hljs-operator": chalk.white,
-    "hljs-punctuation": chalk.white,
-    "hljs-property": chalk.yellow,
-    "hljs-attr": chalk.yellow,
-    "hljs-variable": chalk.white,
-    "hljs-template-variable": chalk.white,
-    "hljs-string": chalk.green,
-    "hljs-char": chalk.green,
-    "hljs-comment": chalk.gray,
-    "hljs-doctag": chalk.gray,
-    "hljs-function": chalk.yellow,
-    "hljs-title": chalk.yellow,
-    "hljs-params": chalk.white,
-    "hljs-tag": chalk.blue,
-    "hljs-name": chalk.blue,
-    "hljs-selector-tag": chalk.blue,
-    "hljs-selector-id": chalk.blue,
-    "hljs-selector-class": chalk.blue,
-    "hljs-selector-attr": chalk.blue,
-    "hljs-selector-pseudo": chalk.blue,
-    "hljs-subst": chalk.white,
-    "hljs-section": chalk.blue.bold,
-    "hljs-bullet": chalk.magenta,
-    "hljs-emphasis": chalk.italic,
-    "hljs-strong": chalk.bold,
-    "hljs-addition": chalk.green,
-    "hljs-deletion": chalk.red,
-    "hljs-link": chalk.blue.underline,
-};
-function nodeToAnsi(node) {
-    if (node instanceof TextNode) {
-        return node.text;
-    }
-    if (node instanceof HTMLElement) {
-        const content = node.childNodes.map(nodeToAnsi).join("");
-        const classes = node.getAttribute("class")?.split(/\s+/) || [];
-        for (const className of classes) {
-            if (theme[className]) {
-                return theme[className](content);
-            }
-        }
-        return content;
-    }
-    return "";
-}
-export function highlightToAnsi(code, language) {
-    if (!code) {
-        return "";
-    }
-    try {
-        const highlighted = language
-            ? hljs.highlight(code, { language }).value
-            : hljs.highlightAuto(code, [
-                "javascript",
-                "typescript",
-                "bash",
-                "json",
-                "markdown",
-                "python",
-                "yaml",
-                "html",
-                "css",
-                "sql",
-                "xml",
-                "rust",
-                "go",
-                "java",
-                "cpp",
-                "c",
-                "csharp",
-                "php",
-                "ruby",
-                "swift",
-                "kotlin",
-                "toml",
-                "ini",
-            ]).value;
-        const root = parse(highlighted);
-        return root.childNodes.map(nodeToAnsi).join("");
-    }
-    catch {
-        return code;
-    }
-}

package/dist/utils/inputUtils.d.ts

@@ -1,17 +0,0 @@
-export declare const expandLongTextPlaceholders: (text: string, longTextMap: Record<string, string>) => string;
-export declare const getAtSelectorPosition: (text: string, cursorPosition: number) => number;
-export declare const getSlashSelectorPosition: (text: string, cursorPosition: number) => number;
-export declare const getWordEnd: (text: string, startPos: number) => number;
-export declare const SELECTOR_TRIGGERS: readonly [{
-    readonly char: "@";
-    readonly type: "ACTIVATE_FILE_SELECTOR";
-    readonly shouldActivate: (char: string, pos: number, text: string) => boolean;
-}, {
-    readonly char: "/";
-    readonly type: "ACTIVATE_COMMAND_SELECTOR";
-    readonly shouldActivate: (char: string, pos: number, text: string, showFileSelector: boolean) => boolean;
-}];
-export declare const getProjectedState: (inputText: string, cursorPosition: number, char: string) => {
-    newInputText: string;
-    newCursorPosition: number;
-};