wave-code 0.0.2

package/dist/hooks/usePagination.js

@@ -0,0 +1,168 @@
+import { useState, useEffect, useMemo } from "react";
+import { useInput } from "ink";
+import { MESSAGES_PER_PAGE } from "../utils/constants.js";
+export const usePagination = (messages) => {
+    const messagesPerPage = MESSAGES_PER_PAGE;
+    // Calculate pagination info, ensuring first page can be incomplete while subsequent pages are complete
+    const paginationInfo = useMemo(() => {
+        if (messages.length <= messagesPerPage) {
+            // If total messages don't exceed one page, display all messages directly
+            return {
+                currentPage: 1,
+                totalPages: 1,
+                startIndex: 0,
+                endIndex: messages.length,
+                messagesPerPage,
+            };
+        }
+        // Calculate remaining messages (messages other than the first page)
+        const remainingMessages = messages.length % messagesPerPage;
+        if (remainingMessages === 0) {
+            // Message count fits perfectly into complete pages, use standard pagination
+            const totalPages = Math.ceil(messages.length / messagesPerPage);
+            const currentPage = totalPages;
+            const startIndex = (currentPage - 1) * messagesPerPage;
+            const endIndex = messages.length;
+            return {
+                currentPage,
+                totalPages,
+                startIndex,
+                endIndex,
+                messagesPerPage,
+            };
+        }
+        else {
+            // Has remaining messages, let first page display remaining messages, subsequent pages are complete
+            const firstPageMessageCount = remainingMessages;
+            const totalPages = Math.floor(messages.length / messagesPerPage) + 1;
+            // Default to showing the last page (complete page)
+            const currentPage = totalPages;
+            const startIndex = firstPageMessageCount + (currentPage - 2) * messagesPerPage;
+            const endIndex = messages.length;
+            return {
+                currentPage,
+                totalPages,
+                startIndex,
+                endIndex,
+                messagesPerPage,
+            };
+        }
+    }, [messages.length, messagesPerPage]);
+    // Manually controlled current page (for keyboard navigation)
+    const [manualPage, setManualPage] = useState(null);
+    // Calculate actual display page info
+    const displayInfo = useMemo(() => {
+        if (manualPage === null) {
+            return paginationInfo; // Auto mode: display last page
+        }
+        // Manual mode: display user-selected page
+        const totalPages = paginationInfo.totalPages;
+        const currentPage = Math.min(Math.max(1, manualPage), totalPages);
+        if (messages.length <= messagesPerPage) {
+            // Only one page case
+            return {
+                currentPage,
+                totalPages,
+                startIndex: 0,
+                endIndex: messages.length,
+                messagesPerPage,
+            };
+        }
+        const remainingMessages = messages.length % messagesPerPage;
+        if (remainingMessages === 0) {
+            // Message count fits perfectly into complete pages
+            const startIndex = (currentPage - 1) * messagesPerPage;
+            const endIndex = Math.min(startIndex + messagesPerPage, messages.length);
+            return {
+                currentPage,
+                totalPages,
+                startIndex,
+                endIndex,
+                messagesPerPage,
+            };
+        }
+        else {
+            // First page incomplete, subsequent pages complete
+            if (currentPage === 1) {
+                // First page: display remaining message count
+                return {
+                    currentPage,
+                    totalPages,
+                    startIndex: 0,
+                    endIndex: remainingMessages,
+                    messagesPerPage,
+                };
+            }
+            else {
+                // Other pages: display complete message count per page
+                const firstPageMessageCount = remainingMessages;
+                const startIndex = firstPageMessageCount + (currentPage - 2) * messagesPerPage;
+                const endIndex = Math.min(startIndex + messagesPerPage, messages.length);
+                return {
+                    currentPage,
+                    totalPages,
+                    startIndex,
+                    endIndex,
+                    messagesPerPage,
+                };
+            }
+        }
+    }, [messages.length, messagesPerPage, manualPage, paginationInfo]);
+    // When message count changes, if user hasn't manually navigated, reset to auto mode
+    useEffect(() => {
+        if (manualPage !== null) {
+            // If user is currently on the last page, keep auto mode
+            const totalPages = Math.ceil(messages.length / messagesPerPage);
+            if (manualPage >= totalPages) {
+                setManualPage(null);
+            }
+        }
+    }, [messages.length, messagesPerPage, manualPage]);
+    // Pagination functionality
+    const goToPage = (page) => {
+        setManualPage(page);
+    };
+    const goToPrevPage = () => {
+        const currentPage = manualPage ?? displayInfo.currentPage;
+        setManualPage(Math.max(1, currentPage - 1));
+    };
+    const goToNextPage = () => {
+        const currentPage = manualPage ?? displayInfo.currentPage;
+        setManualPage(Math.min(displayInfo.totalPages, currentPage + 1));
+    };
+    const goToFirstPage = () => {
+        setManualPage(1);
+    };
+    const goToLastPage = () => {
+        setManualPage(null); // Return to auto mode (last page)
+    };
+    // Integrate keyboard shortcut handling
+    useInput((input, key) => {
+        // Ctrl+U/D shortcuts (Vim/Less style)
+        if (key.ctrl) {
+            if (input === "u") {
+                goToPrevPage();
+            }
+            else if (input === "d") {
+                goToNextPage();
+            }
+        }
+        // Page Up/Down support
+        if (key.pageUp) {
+            goToPrevPage();
+        }
+        if (key.pageDown) {
+            goToNextPage();
+        }
+    });
+    return {
+        displayInfo,
+        manualPage,
+        setManualPage,
+        goToPage,
+        goToPrevPage,
+        goToNextPage,
+        goToFirstPage,
+        goToLastPage,
+    };
+};

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+export declare function main(): Promise<void>;
+export { startCli } from "./cli.js";
+export { logger } from "./utils/logger.js";
+export { readClipboardImage, cleanupTempImage, hasClipboardImage, type ClipboardImageResult, } from "./utils/clipboard.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAMA,wBAAsB,IAAI,kBA+EzB;AAGD,OAAO,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAC;AAGpC,OAAO,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAG3C,OAAO,EACL,kBAAkB,EAClB,gBAAgB,EAChB,iBAAiB,EACjB,KAAK,oBAAoB,GAC1B,MAAM,sBAAsB,CAAC"}

package/dist/index.js

@@ -0,0 +1,91 @@
+import yargs from "yargs";
+import { hideBin } from "yargs/helpers";
+import { startCli } from "./cli.js";
+import { listSessions } from "wave-agent-sdk";
+// Export main function for external use
+export async function main() {
+    const argv = await yargs(hideBin(process.argv))
+        .option("restore", {
+        alias: "r",
+        description: "Restore session by ID",
+        type: "string",
+    })
+        .option("continue", {
+        alias: "c",
+        description: "Continue from last session",
+        type: "boolean",
+    })
+        .option("plain", {
+        alias: "p",
+        description: "Plain mode with message to send",
+        type: "string",
+    })
+        .option("list-sessions", {
+        description: "List all available sessions",
+        type: "boolean",
+    })
+        .version()
+        .alias("v", "version")
+        .example("$0", "Start CLI with default settings")
+        .example("$0 --restore session_123", "Restore specific session")
+        .example("$0 --continue", "Continue from last session")
+        .example("$0 --plain 'Hello'", "Send message in plain mode")
+        .example("$0 -p 'Hello'", "Send message in plain mode (short)")
+        .example("$0 --list-sessions", "List all available sessions")
+        .help("h")
+        .parseAsync();
+    // Handle list sessions command
+    if (argv.listSessions) {
+        try {
+            const currentWorkdir = process.cwd();
+            const sessions = await listSessions(currentWorkdir);
+            if (sessions.length === 0) {
+                console.log(`No sessions found for workdir: ${currentWorkdir}`);
+                return;
+            }
+            console.log(`Available sessions for: ${currentWorkdir}`);
+            console.log("==========================================");
+            for (const session of sessions) {
+                const startedAt = new Date(session.startedAt).toLocaleString();
+                const lastActiveAt = new Date(session.lastActiveAt).toLocaleString();
+                console.log(`ID: ${session.id}`);
+                console.log(`  Workdir: ${session.workdir}`);
+                console.log(`  Started: ${startedAt}`);
+                console.log(`  Last Active: ${lastActiveAt}`);
+                console.log(`  Last Message Tokens: ${session.latestTotalTokens}`);
+                console.log("");
+            }
+            return;
+        }
+        catch (error) {
+            console.error("Failed to list sessions:", error);
+            process.exit(1);
+        }
+    }
+    // Handle plain mode directly
+    if (argv.plain !== undefined) {
+        const { startPlainCli } = await import("./plain-cli.js");
+        return startPlainCli({
+            restoreSessionId: argv.restore,
+            continueLastSession: argv.continue,
+            message: argv.plain,
+        });
+    }
+    await startCli({
+        restoreSessionId: argv.restore,
+        continueLastSession: argv.continue,
+    });
+}
+// Export CLI function
+export { startCli } from "./cli.js";
+// Export logger
+export { logger } from "./utils/logger.js";
+// Export clipboard utilities
+export { readClipboardImage, cleanupTempImage, hasClipboardImage, } from "./utils/clipboard.js";
+// Execute main function if this file is run directly
+if (import.meta.url === `file://${process.argv[1]}`) {
+    main().catch((error) => {
+        console.error("Failed to start WAVE Code:", error);
+        process.exit(1);
+    });
+}

package/dist/plain-cli.d.ts

@@ -0,0 +1,7 @@
+export interface PlainCliOptions {
+    restoreSessionId?: string;
+    continueLastSession?: boolean;
+    message?: string;
+}
+export declare function startPlainCli(options: PlainCliOptions): Promise<void>;
+//# sourceMappingURL=plain-cli.d.ts.map

package/dist/plain-cli.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"plain-cli.d.ts","sourceRoot":"","sources":["../src/plain-cli.ts"],"names":[],"mappings":"AAGA,MAAM,WAAW,eAAe;IAC9B,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,mBAAmB,CAAC,EAAE,OAAO,CAAC;IAC9B,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED,wBAAsB,aAAa,CAAC,OAAO,EAAE,eAAe,GAAG,OAAO,CAAC,IAAI,CAAC,CAwD3E"}

package/dist/plain-cli.js

@@ -0,0 +1,49 @@
+import { Agent } from "wave-agent-sdk";
+import { logger } from "./utils/logger.js";
+export async function startPlainCli(options) {
+    const { restoreSessionId, continueLastSession, message } = options;
+    if ((!message || message.trim() === "") &&
+        !continueLastSession &&
+        !restoreSessionId) {
+        console.error("Plain mode requires a message: use --plain 'your message' or -p 'your message'");
+        process.exit(1);
+    }
+    let agent;
+    let lastAssistantMessage;
+    // Setup callbacks for agent
+    const callbacks = {
+        onAssistantMessageAdded: (content) => {
+            // Store the content instead of immediately printing it
+            if (content) {
+                lastAssistantMessage = content;
+            }
+        },
+    };
+    try {
+        // Initialize agent
+        agent = await Agent.create({
+            callbacks,
+            restoreSessionId,
+            continueLastSession,
+            logger,
+        });
+        // Send message if provided and not empty
+        if (message && message.trim() !== "") {
+            await agent.sendMessage(message);
+        }
+        // Output only the last assistant message
+        if (lastAssistantMessage) {
+            console.log(lastAssistantMessage);
+        }
+        // Destroy agent and exit after sendMessage completes
+        agent.destroy();
+        process.exit(0);
+    }
+    catch (error) {
+        console.error("Failed to send message:", error);
+        if (agent) {
+            agent.destroy();
+        }
+        process.exit(1);
+    }
+}

package/dist/utils/clipboard.d.ts

@@ -0,0 +1,22 @@
+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>;
+//# sourceMappingURL=clipboard.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"clipboard.d.ts","sourceRoot":"","sources":["../../src/utils/clipboard.ts"],"names":[],"mappings":"AAIA,MAAM,WAAW,oBAAoB;IACnC,OAAO,EAAE,OAAO,CAAC;IACjB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED;;;GAGG;AACH,wBAAsB,kBAAkB,IAAI,OAAO,CAAC,oBAAoB,CAAC,CAsBxE;AAsOD;;;GAGG;AACH,wBAAgB,gBAAgB,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI,CAQxD;AAED;;;GAGG;AACH,wBAAsB,iBAAiB,IAAI,OAAO,CAAC,OAAO,CAAC,CAgB1D"}