wave-agent-sdk 0.0.1

package/dist/services/memory.js

@@ -0,0 +1,128 @@
+import { promises as fs } from "fs";
+import path from "path";
+import { USER_MEMORY_FILE, DATA_DIRECTORY } from "../utils/constants.js";
+// Project memory related methods
+export const isMemoryMessage = (message) => {
+    return message.trim().startsWith("#");
+};
+export const addMemory = async (message, workdir) => {
+    if (!isMemoryMessage(message)) {
+        return;
+    }
+    try {
+        const memoryFilePath = path.join(workdir, "WAVE.md");
+        // Format memory entry, starting with -, no timestamp
+        const memoryEntry = `- ${message.substring(1).trim()}\n`;
+        // Check if file exists
+        let existingContent = "";
+        try {
+            existingContent = await fs.readFile(memoryFilePath, "utf-8");
+        }
+        catch (error) {
+            // File does not exist, create new file
+            if (error.code === "ENOENT") {
+                existingContent =
+                    "# Memory\n\nThis is the AI assistant's memory file, recording important information and context.\n\n";
+            }
+            else {
+                throw error;
+            }
+        }
+        // Append new memory entry to the end of the file
+        const updatedContent = existingContent + memoryEntry;
+        // Write file
+        await fs.writeFile(memoryFilePath, updatedContent, "utf-8");
+        // logger.info(`Memory added to ${memoryFilePath}:`, message);
+    }
+    catch (error) {
+        // logger.error("Failed to add memory:", error);
+        throw new Error(`Failed to add memory: ${error.message}`);
+    }
+};
+// User memory related methods
+export const ensureUserMemoryFile = async () => {
+    try {
+        // Ensure data directory exists
+        await fs.mkdir(DATA_DIRECTORY, { recursive: true });
+        // Check if user memory file exists
+        try {
+            await fs.access(USER_MEMORY_FILE);
+        }
+        catch (error) {
+            // File does not exist, create new file
+            if (error.code === "ENOENT") {
+                const initialContent = "# User Memory\n\nThis is the user-level memory file, recording important information and context across projects.\n\n";
+                await fs.writeFile(USER_MEMORY_FILE, initialContent, "utf-8");
+                // logger.info(`Created user memory file: ${USER_MEMORY_FILE}`);
+            }
+            else {
+                throw error;
+            }
+        }
+    }
+    catch (error) {
+        // logger.error("Failed to ensure user memory file:", error);
+        throw new Error(`Failed to ensure user memory file: ${error.message}`);
+    }
+};
+export const addUserMemory = async (message) => {
+    try {
+        // Ensure user memory file exists
+        await ensureUserMemoryFile();
+        // Format memory entry, starting with -
+        const memoryEntry = `- ${message.substring(1).trim()}\n`;
+        // Read existing content
+        const existingContent = await fs.readFile(USER_MEMORY_FILE, "utf-8");
+        // Append new memory entry to the end of the file
+        const updatedContent = existingContent + memoryEntry;
+        // Write file
+        await fs.writeFile(USER_MEMORY_FILE, updatedContent, "utf-8");
+        // logger.info(`User memory added to ${USER_MEMORY_FILE}:`, message);
+    }
+    catch (error) {
+        // logger.error("Failed to add user memory:", error);
+        throw new Error(`Failed to add user memory: ${error.message}`);
+    }
+};
+export const getUserMemoryContent = async () => {
+    try {
+        await ensureUserMemoryFile();
+        return await fs.readFile(USER_MEMORY_FILE, "utf-8");
+    }
+    catch {
+        // logger.error("Failed to read user memory:", error);
+        return "";
+    }
+};
+// Read project memory file content
+export const readMemoryFile = async (workdir) => {
+    try {
+        const memoryFilePath = path.join(workdir, "WAVE.md");
+        return await fs.readFile(memoryFilePath, "utf-8");
+    }
+    catch (error) {
+        if (error.code === "ENOENT") {
+            return "";
+        }
+        throw error;
+    }
+};
+// Get merged memory content (project memory + user memory)
+export const getCombinedMemoryContent = async (workdir) => {
+    // Read memory file content
+    const memoryContent = await readMemoryFile(workdir);
+    // Read user-level memory content
+    const userMemoryContent = await getUserMemoryContent();
+    // Merge project memory and user memory
+    let combinedMemory = "";
+    if (memoryContent.trim()) {
+        combinedMemory += memoryContent;
+    }
+    if (userMemoryContent.trim()) {
+        if (combinedMemory) {
+            combinedMemory += "\n\n";
+        }
+        combinedMemory += userMemoryContent;
+    }
+    return combinedMemory;
+};

package/dist/services/session.d.ts

@@ -0,0 +1,54 @@
+import type { Message } from "../types.js";
+export interface SessionData {
+    id: string;
+    timestamp: string;
+    version: string;
+    messages: Message[];
+    metadata: {
+        workdir: string;
+        startedAt: string;
+        lastActiveAt: string;
+        latestTotalTokens: number;
+    };
+}
+export interface SessionMetadata {
+    id: string;
+    timestamp: string;
+    workdir: string;
+    startedAt: string;
+    lastActiveAt: string;
+    latestTotalTokens: number;
+}
+/**
+ * Generate session file path
+ */
+export declare function getSessionFilePath(sessionId: string): string;
+/**
+ * Save session data
+ */
+export declare function saveSession(sessionId: string, messages: Message[], workdir: string, latestTotalTokens?: number, startedAt?: string): Promise<void>;
+/**
+ * Load session data
+ */
+export declare function loadSession(sessionId: string): Promise<SessionData | null>;
+/**
+ * Get most recent session
+ */
+export declare function getLatestSession(workdir: string): Promise<SessionData | null>;
+/**
+ * List all sessions
+ */
+export declare function listSessions(workdir: string, includeAllWorkdirs?: boolean): Promise<SessionMetadata[]>;
+/**
+ * Delete session
+ */
+export declare function deleteSession(sessionId: string): Promise<boolean>;
+/**
+ * Clean up expired sessions
+ */
+export declare function cleanupExpiredSessions(workdir: string): Promise<number>;
+/**
+ * Check if session exists
+ */
+export declare function sessionExists(sessionId: string): Promise<boolean>;
+//# sourceMappingURL=session.d.ts.map

package/dist/services/session.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"session.d.ts","sourceRoot":"","sources":["../../src/services/session.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,aAAa,CAAC;AAE3C,MAAM,WAAW,WAAW;IAC1B,EAAE,EAAE,MAAM,CAAC;IACX,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,OAAO,EAAE,CAAC;IACpB,QAAQ,EAAE;QACR,OAAO,EAAE,MAAM,CAAC;QAChB,SAAS,EAAE,MAAM,CAAC;QAClB,YAAY,EAAE,MAAM,CAAC;QACrB,iBAAiB,EAAE,MAAM,CAAC;KAC3B,CAAC;CACH;AAED,MAAM,WAAW,eAAe;IAC9B,EAAE,EAAE,MAAM,CAAC;IACX,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,MAAM,CAAC;IAClB,YAAY,EAAE,MAAM,CAAC;IACrB,iBAAiB,EAAE,MAAM,CAAC;CAC3B;AAkBD;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAG5D;AAcD;;GAEG;AACH,wBAAsB,WAAW,CAC/B,SAAS,EAAE,MAAM,EACjB,QAAQ,EAAE,OAAO,EAAE,EACnB,OAAO,EAAE,MAAM,EACf,iBAAiB,GAAE,MAAU,EAC7B,SAAS,CAAC,EAAE,MAAM,GACjB,OAAO,CAAC,IAAI,CAAC,CA+Bf;AAED;;GAEG;AACH,wBAAsB,WAAW,CAC/B,SAAS,EAAE,MAAM,GAChB,OAAO,CAAC,WAAW,GAAG,IAAI,CAAC,CAmB7B;AAED;;GAEG;AACH,wBAAsB,gBAAgB,CACpC,OAAO,EAAE,MAAM,GACd,OAAO,CAAC,WAAW,GAAG,IAAI,CAAC,CAa7B;AAED;;GAEG;AACH,wBAAsB,YAAY,CAChC,OAAO,EAAE,MAAM,EACf,kBAAkB,UAAQ,GACzB,OAAO,CAAC,eAAe,EAAE,CAAC,CA2C5B;AAED;;GAEG;AACH,wBAAsB,aAAa,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAYvE;AAED;;GAEG;AACH,wBAAsB,sBAAsB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CA4B7E;AAED;;GAEG;AACH,wBAAsB,aAAa,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CASvE"}

package/dist/services/session.js

@@ -0,0 +1,196 @@
+import { promises as fs } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+// Constants
+const SESSION_DIR = join(homedir(), ".wave", "sessions");
+const VERSION = "1.0.0";
+const MAX_SESSION_AGE_DAYS = 30;
+/**
+ * Ensure session directory exists
+ */
+async function ensureSessionDir() {
+    try {
+        await fs.mkdir(SESSION_DIR, { recursive: true });
+    }
+    catch (error) {
+        throw new Error(`Failed to create session directory: ${error}`);
+    }
+}
+/**
+ * Generate session file path
+ */
+export function getSessionFilePath(sessionId) {
+    const shortId = sessionId.split("_")[2] || sessionId.slice(-8);
+    return join(SESSION_DIR, `session_${shortId}.json`);
+}
+/**
+ * Filter out diff blocks from messages to avoid saving unimportant data
+ */
+function filterDiffBlocks(messages) {
+    return messages
+        .map((message) => ({
+        ...message,
+        blocks: message.blocks.filter((block) => block.type !== "diff"),
+    }))
+        .filter((message) => message.blocks.length > 0);
+}
+/**
+ * Save session data
+ */
+export async function saveSession(sessionId, messages, workdir, latestTotalTokens = 0, startedAt) {
+    // Do not save session files in test environment
+    if (process.env.NODE_ENV === "test") {
+        return;
+    }
+    await ensureSessionDir();
+    // Filter out diff blocks before saving
+    const filteredMessages = filterDiffBlocks(messages);
+    const now = new Date().toISOString();
+    const sessionData = {
+        id: sessionId,
+        timestamp: now,
+        version: VERSION,
+        messages: filteredMessages,
+        metadata: {
+            workdir: workdir,
+            startedAt: startedAt || now,
+            lastActiveAt: now,
+            latestTotalTokens,
+        },
+    };
+    const filePath = getSessionFilePath(sessionId);
+    try {
+        await fs.writeFile(filePath, JSON.stringify(sessionData, null, 2), "utf-8");
+    }
+    catch (error) {
+        throw new Error(`Failed to save session ${sessionId}: ${error}`);
+    }
+}
+/**
+ * Load session data
+ */
+export async function loadSession(sessionId) {
+    const filePath = getSessionFilePath(sessionId);
+    try {
+        const content = await fs.readFile(filePath, "utf-8");
+        const sessionData = JSON.parse(content);
+        // Validate session data format
+        if (!sessionData.id || !sessionData.messages || !sessionData.metadata) {
+            throw new Error("Invalid session data format");
+        }
+        return sessionData;
+    }
+    catch (error) {
+        if (error.code === "ENOENT") {
+            return null; // Session file does not exist
+        }
+        throw new Error(`Failed to load session ${sessionId}: ${error}`);
+    }
+}
+/**
+ * Get most recent session
+ */
+export async function getLatestSession(workdir) {
+    const sessions = await listSessions(workdir);
+    if (sessions.length === 0) {
+        return null;
+    }
+    // Sort by last active time, return the latest
+    const latestSession = sessions.sort((a, b) => new Date(b.lastActiveAt).getTime() - new Date(a.lastActiveAt).getTime())[0];
+    return loadSession(latestSession.id);
+}
+/**
+ * List all sessions
+ */
+export async function listSessions(workdir, includeAllWorkdirs = false) {
+    try {
+        await ensureSessionDir();
+        const files = await fs.readdir(SESSION_DIR);
+        const sessions = [];
+        for (const file of files) {
+            if (!file.startsWith("session_") || !file.endsWith(".json")) {
+                continue;
+            }
+            try {
+                const filePath = join(SESSION_DIR, file);
+                const content = await fs.readFile(filePath, "utf-8");
+                const sessionData = JSON.parse(content);
+                // Only return sessions for the current working directory, unless includeAllWorkdirs is true
+                if (!includeAllWorkdirs && sessionData.metadata.workdir !== workdir) {
+                    continue;
+                }
+                sessions.push({
+                    id: sessionData.id,
+                    timestamp: sessionData.timestamp,
+                    workdir: sessionData.metadata.workdir,
+                    startedAt: sessionData.metadata.startedAt,
+                    lastActiveAt: sessionData.metadata.lastActiveAt,
+                    latestTotalTokens: sessionData.metadata.latestTotalTokens,
+                });
+            }
+            catch {
+                // Ignore corrupted session files
+                console.warn(`Skipping corrupted session file: ${file}`);
+            }
+        }
+        return sessions.sort((a, b) => new Date(b.lastActiveAt).getTime() - new Date(a.lastActiveAt).getTime());
+    }
+    catch (error) {
+        throw new Error(`Failed to list sessions: ${error}`);
+    }
+}
+/**
+ * Delete session
+ */
+export async function deleteSession(sessionId) {
+    const filePath = getSessionFilePath(sessionId);
+    try {
+        await fs.unlink(filePath);
+        return true;
+    }
+    catch (error) {
+        if (error.code === "ENOENT") {
+            return false; // File does not exist
+        }
+        throw new Error(`Failed to delete session ${sessionId}: ${error}`);
+    }
+}
+/**
+ * Clean up expired sessions
+ */
+export async function cleanupExpiredSessions(workdir) {
+    // Do not perform cleanup operations in test environment
+    if (process.env.NODE_ENV === "test") {
+        return 0;
+    }
+    const sessions = await listSessions(workdir, true);
+    const now = new Date();
+    const maxAge = MAX_SESSION_AGE_DAYS * 24 * 60 * 60 * 1000; // Convert to milliseconds
+    let deletedCount = 0;
+    for (const session of sessions) {
+        const sessionAge = now.getTime() - new Date(session.lastActiveAt).getTime();
+        if (sessionAge > maxAge) {
+            try {
+                await deleteSession(session.id);
+                deletedCount++;
+            }
+            catch (error) {
+                console.warn(`Failed to delete expired session ${session.id}: ${error}`);
+            }
+        }
+    }
+    return deletedCount;
+}
+/**
+ * Check if session exists
+ */
+export async function sessionExists(sessionId) {
+    const filePath = getSessionFilePath(sessionId);
+    try {
+        await fs.access(filePath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/tools/bashTool.d.ts

@@ -0,0 +1,14 @@
+import type { ToolPlugin } from "./types.js";
+/**
+ * Bash command execution tool - supports both foreground and background execution
+ */
+export declare const bashTool: ToolPlugin;
+/**
+ * BashOutput tool - retrieves output from background bash shells
+ */
+export declare const bashOutputTool: ToolPlugin;
+/**
+ * KillBash tool - kills a running background bash shell
+ */
+export declare const killBashTool: ToolPlugin;
+//# sourceMappingURL=bashTool.d.ts.map

package/dist/tools/bashTool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bashTool.d.ts","sourceRoot":"","sources":["../../src/tools/bashTool.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,UAAU,EAA2B,MAAM,YAAY,CAAC;AAEtE;;GAEG;AACH,eAAO,MAAM,QAAQ,EAAE,UA2NtB,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,cAAc,EAAE,UAwF5B,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,YAAY,EAAE,UA8E1B,CAAC"}