wave-agent-sdk 0.0.6 → 0.0.8

package/dist/services/session.js

@@ -1,196 +1,320 @@
 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;
+import { v6 as uuidv6 } from "uuid";
+import { PathEncoder } from "../utils/pathEncoder.js";
+import { JsonlHandler } from "../services/jsonlHandler.js";
+import { extractLatestTotalTokens } from "../utils/tokenCalculation.js";
 /**
- * Resolve session directory path with fallback to default
- * @param sessionDir Optional custom session directory
- * @returns Resolved session directory path
+ * Generate a new UUIDv6-based session ID
+ * @returns UUIDv6 string for time-ordered sessions
  */
-export function resolveSessionDir(sessionDir) {
-    return sessionDir || SESSION_DIR;
+export function generateSessionId() {
+    return uuidv6();
 }
+// Constants
+export const SESSION_DIR = join(homedir(), ".wave", "projects");
+const MAX_SESSION_AGE_DAYS = 14;
 /**
  * Ensure session directory exists
- * @param sessionDir Optional custom session directory
  */
-export async function ensureSessionDir(sessionDir) {
-    const resolvedDir = resolveSessionDir(sessionDir);
+export async function ensureSessionDir() {
     try {
-        await fs.mkdir(resolvedDir, { recursive: true });
+        await fs.mkdir(SESSION_DIR, { recursive: true });
     }
     catch (error) {
         throw new Error(`Failed to create session directory: ${error}`);
     }
 }
 /**
- * Generate session file path
+ * Generate session file path using project-based directory structure
+ * Note: With metadata-based approach, we no longer need separate subagent directories
+ * @param sessionId - UUIDv6 session identifier
+ * @param workdir - Working directory for the session
+ * @returns Promise resolving to full file path for the session JSONL file
  */
-export function getSessionFilePath(sessionId, sessionDir) {
-    const shortId = sessionId.split("_")[2] || sessionId.slice(-8);
-    const resolvedDir = resolveSessionDir(sessionDir);
-    return join(resolvedDir, `session_${shortId}.json`);
+export async function getSessionFilePath(sessionId, workdir) {
+    const encoder = new PathEncoder();
+    const projectDir = await encoder.createProjectDirectory(workdir, SESSION_DIR);
+    // All sessions (main and subagent) now go in the same directory
+    // Session type is determined by metadata, not file path
+    return join(projectDir.encodedPath, `${sessionId}.jsonl`);
 }
 /**
- * Filter out diff blocks from messages to avoid saving unimportant data
+ * Create a new session with metadata
+ * @param sessionId - UUIDv6 session identifier
+ * @param workdir - Working directory for the session
+ * @param sessionType - Type of session ('main' or 'subagent')
+ * @param parentSessionId - Parent session ID for subagent sessions
+ * @param subagentType - Type of subagent for subagent sessions
  */
-function filterDiffBlocks(messages) {
-    return messages
-        .map((message) => ({
-        ...message,
-        blocks: message.blocks.filter((block) => block.type !== "diff"),
-    }))
-        .filter((message) => message.blocks.length > 0);
+export async function createSession(sessionId, workdir, sessionType = "main", parentSessionId, subagentType) {
+    const jsonlHandler = new JsonlHandler();
+    const filePath = await getSessionFilePath(sessionId, workdir);
+    await jsonlHandler.createSession(filePath, sessionId, workdir, sessionType, parentSessionId, subagentType);
 }
 /**
- * Save session data to storage
+ * Append messages to session using JSONL format (new approach)
  *
- * @param sessionId - Unique identifier for the session
- * @param messages - Array of messages to save
+ * @param sessionId - UUIDv6 session identifier
+ * @param newMessages - Array of messages to append
  * @param workdir - Working directory for the session
- * @param latestTotalTokens - Total tokens used in the session
- * @param startedAt - ISO timestamp when session started (defaults to current time)
- * @param sessionDir - Optional custom directory for session storage (defaults to ~/.wave/sessions/)
- * @throws {Error} When session cannot be saved due to permission or disk space issues
  */
-export async function saveSession(sessionId, messages, workdir, latestTotalTokens = 0, startedAt, sessionDir) {
+export async function appendMessages(sessionId, newMessages, workdir) {
     // Do not save session files in test environment
     if (process.env.NODE_ENV === "test") {
         return;
     }
     // Do not save if there are no messages
-    if (messages.length === 0) {
+    if (newMessages.length === 0) {
         return;
     }
-    await ensureSessionDir(sessionDir);
-    // 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, sessionDir);
+    const jsonlHandler = new JsonlHandler();
+    const filePath = await getSessionFilePath(sessionId, workdir);
+    // Check if session file exists, throw error if it doesn't
     try {
-        await fs.writeFile(filePath, JSON.stringify(sessionData, null, 2), "utf-8");
+        await fs.access(filePath);
     }
     catch (error) {
-        throw new Error(`Failed to save session ${sessionId}: ${error}`);
+        if (error.code === "ENOENT") {
+            // File doesn't exist, throw error - sessions must be created explicitly
+            throw new Error(`Session file not found: ${sessionId}. Use createSession() to create a new session first.`);
+        }
+        else {
+            // Some other error accessing the file, re-throw it
+            throw error;
+        }
     }
+    const messagesWithTimestamp = newMessages.map((msg) => ({
+        timestamp: new Date().toISOString(),
+        ...msg,
+    }));
+    await jsonlHandler.append(filePath, messagesWithTimestamp, { atomic: false });
 }
 /**
- * Load session data from storage
+ * Load session data from JSONL file (new approach)
  *
- * @param sessionId - Unique identifier for the session to load
- * @param sessionDir - Optional custom directory for session storage (defaults to ~/.wave/sessions/)
+ * @param sessionId - UUIDv6 session identifier
+ * @param workdir - Working directory for the session
  * @returns Promise that resolves to session data or null if session doesn't exist
- * @throws {Error} When session exists but cannot be read or contains invalid data
  */
-export async function loadSession(sessionId, sessionDir) {
-    const filePath = getSessionFilePath(sessionId, sessionDir);
+export async function loadSessionFromJsonl(sessionId, workdir) {
     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");
+        const jsonlHandler = new JsonlHandler();
+        const filePath = await getSessionFilePath(sessionId, workdir);
+        const messages = await jsonlHandler.read(filePath);
+        if (messages.length === 0) {
+            return null;
         }
+        // Extract metadata from messages
+        const firstMessage = messages[0];
+        const lastMessage = messages[messages.length - 1];
+        const sessionData = {
+            id: sessionId,
+            messages: messages.map((msg) => {
+                // Remove timestamp property for backward compatibility
+                const { timestamp: _ignored, ...messageWithoutTimestamp } = msg;
+                void _ignored; // Use the variable to avoid eslint error
+                return messageWithoutTimestamp;
+            }),
+            metadata: {
+                workdir,
+                startedAt: firstMessage.timestamp,
+                lastActiveAt: lastMessage.timestamp,
+                latestTotalTokens: lastMessage.usage
+                    ? extractLatestTotalTokens([lastMessage])
+                    : 0,
+            },
+        };
         return sessionData;
     }
     catch (error) {
-        if (error.code === "ENOENT") {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        // Check if the underlying error is ENOENT (file doesn't exist)
+        if (errorMessage.includes("ENOENT") ||
+            error.code === "ENOENT") {
             return null; // Session file does not exist
         }
+        // Check for JSON parsing errors (corrupted files)
+        if (errorMessage.includes("Invalid JSON") ||
+            errorMessage.includes("Unexpected token")) {
+            return null; // Treat corrupted files as non-existent
+        }
         throw new Error(`Failed to load session ${sessionId}: ${error}`);
     }
 }
 /**
- * Get the most recent session for a specific working directory
+ * Get the most recently active session for a specific working directory (new JSONL approach)
+ * Only returns main sessions, skips subagent sessions
+ * Sessions are sorted by last active time (most recently active first)
  *
- * @param workdir - Working directory to find the most recent session for
- * @param sessionDir - Optional custom directory for session storage (defaults to ~/.wave/sessions/)
- * @returns Promise that resolves to the most recent session data or null if no sessions exist
- * @throws {Error} When session directory cannot be accessed or session data is corrupted
+ * @param workdir - Working directory to find the most recently active session for
+ * @returns Promise that resolves to the most recently active session data or null if no sessions exist
  */
-export async function getLatestSession(workdir, sessionDir) {
-    const sessions = await listSessions(workdir, false, sessionDir);
+export async function getLatestSessionFromJsonl(workdir) {
+    const sessions = await listSessionsFromJsonl(workdir, false); // Uses default includeSubagentSessions = false
     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, sessionDir);
+    // Sort by last active time (most recently active first)
+    const latestSession = sessions.sort((a, b) => b.lastActiveAt.getTime() - a.lastActiveAt.getTime())[0];
+    return loadSessionFromJsonl(latestSession.id, workdir);
+}
+/**
+ * List all sessions for a specific working directory (convenience wrapper)
+ * Only returns main sessions, skips subagent sessions
+ *
+ * @param workdir - Working directory to filter sessions by
+ * @returns Promise that resolves to array of session metadata objects
+ */
+export async function listSessions(workdir) {
+    return listSessionsFromJsonl(workdir, false); // Uses default includeSubagentSessions = false
 }
 /**
- * List all sessions for a specific working directory or across all working directories
+ * List all sessions for a specific working directory using JSONL format (new approach)
  *
  * @param workdir - Working directory to filter sessions by
  * @param includeAllWorkdirs - If true, returns sessions from all working directories
- * @param sessionDir - Optional custom directory for session storage (defaults to ~/.wave/sessions/)
+ * @param includeSubagentSessions - If true, includes subagent sessions (default: false for user-facing operations)
  * @returns Promise that resolves to array of session metadata objects
- * @throws {Error} When session directory cannot be accessed or read
  */
-export async function listSessions(workdir, includeAllWorkdirs = false, sessionDir) {
+export async function listSessionsFromJsonl(workdir, includeAllWorkdirs = false, includeSubagentSessions = false) {
     try {
-        await ensureSessionDir(sessionDir);
-        const resolvedDir = resolveSessionDir(sessionDir);
-        const files = await fs.readdir(resolvedDir);
-        const sessions = [];
-        for (const file of files) {
-            if (!file.startsWith("session_") || !file.endsWith(".json")) {
-                continue;
-            }
-            try {
-                const filePath = join(resolvedDir, 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) {
+        const encoder = new PathEncoder();
+        const baseDir = SESSION_DIR;
+        // If not including all workdirs, just scan the specific project directory
+        if (!includeAllWorkdirs) {
+            const projectDir = await encoder.createProjectDirectory(workdir, baseDir);
+            const files = await fs.readdir(projectDir.encodedPath);
+            const sessions = [];
+            for (const file of files) {
+                if (!file.endsWith(".jsonl")) {
+                    continue;
+                }
+                const sessionId = file.replace(".jsonl", "");
+                try {
+                    const jsonlHandler = new JsonlHandler();
+                    const filePath = join(projectDir.encodedPath, file);
+                    // Read metadata (efficient O(1) operation)
+                    const metadata = await jsonlHandler.readMetadata(filePath);
+                    if (metadata) {
+                        // For lastActiveAt and latestTotalTokens, we need the last message
+                        const lastMessage = await jsonlHandler.getLastMessage(filePath);
+                        sessions.push({
+                            id: sessionId,
+                            sessionType: metadata.sessionType,
+                            parentSessionId: metadata.parentSessionId,
+                            subagentType: metadata.subagentType,
+                            workdir: metadata.workdir,
+                            startedAt: new Date(metadata.startedAt),
+                            lastActiveAt: lastMessage
+                                ? new Date(lastMessage.timestamp)
+                                : new Date(metadata.startedAt),
+                            latestTotalTokens: lastMessage?.usage
+                                ? extractLatestTotalTokens([lastMessage])
+                                : 0,
+                        });
+                    }
+                }
+                catch {
+                    // Skip corrupted session files
                     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 {
-                // Skip corrupted session files and continue processing others
-                continue;
+            // Sort by last active time (most recently active first)
+            const sortedSessions = sessions.sort((a, b) => b.lastActiveAt.getTime() - a.lastActiveAt.getTime());
+            // Filter out subagent sessions if requested
+            if (!includeSubagentSessions) {
+                return sortedSessions.filter((session) => session.sessionType === "main");
+            }
+            return sortedSessions;
+        }
+        // For all workdirs, scan all project directories
+        const sessions = [];
+        try {
+            const projectDirs = await fs.readdir(baseDir);
+            for (const projectDirName of projectDirs) {
+                const projectPath = join(baseDir, projectDirName);
+                const stat = await fs.stat(projectPath);
+                if (!stat.isDirectory()) {
+                    continue;
+                }
+                const files = await fs.readdir(projectPath);
+                for (const file of files) {
+                    if (!file.endsWith(".jsonl")) {
+                        continue;
+                    }
+                    const sessionId = file.replace(".jsonl", "");
+                    try {
+                        const jsonlHandler = new JsonlHandler();
+                        const filePath = join(projectPath, file);
+                        // Read metadata (efficient O(1) operation)
+                        const metadata = await jsonlHandler.readMetadata(filePath);
+                        if (metadata) {
+                            // For lastActiveAt and latestTotalTokens, we need the last message
+                            const lastMessage = await jsonlHandler.getLastMessage(filePath);
+                            sessions.push({
+                                id: sessionId,
+                                sessionType: metadata.sessionType,
+                                parentSessionId: metadata.parentSessionId,
+                                subagentType: metadata.subagentType,
+                                workdir: metadata.workdir,
+                                startedAt: new Date(metadata.startedAt),
+                                lastActiveAt: lastMessage
+                                    ? new Date(lastMessage.timestamp)
+                                    : new Date(metadata.startedAt),
+                                latestTotalTokens: lastMessage?.usage
+                                    ? extractLatestTotalTokens([lastMessage])
+                                    : 0,
+                            });
+                        }
+                    }
+                    catch {
+                        // Skip corrupted session files
+                        continue;
+                    }
+                }
             }
         }
-        return sessions.sort((a, b) => new Date(b.lastActiveAt).getTime() - new Date(a.lastActiveAt).getTime());
+        catch {
+            // If base directory doesn't exist, return empty array
+            return [];
+        }
+        // Sort by last active time (most recently active first)
+        const sortedSessions = sessions.sort((a, b) => b.lastActiveAt.getTime() - a.lastActiveAt.getTime());
+        // Filter out subagent sessions if requested
+        if (!includeSubagentSessions) {
+            return sortedSessions.filter((session) => session.sessionType === "main");
+        }
+        return sortedSessions;
     }
     catch (error) {
         throw new Error(`Failed to list sessions: ${error}`);
     }
 }
 /**
- * Delete a session from storage
+ * Delete a session from JSONL storage (new approach)
  *
- * @param sessionId - Unique identifier for the session to delete
- * @param sessionDir - Optional custom directory for session storage (defaults to ~/.wave/sessions/)
+ * @param sessionId - UUIDv6 session identifier
+ * @param workdir - Working directory for the session
  * @returns Promise that resolves to true if session was deleted, false if it didn't exist
- * @throws {Error} When session exists but cannot be deleted due to permission issues
  */
-export async function deleteSession(sessionId, sessionDir) {
-    const filePath = getSessionFilePath(sessionId, sessionDir);
+export async function deleteSessionFromJsonl(sessionId, workdir) {
     try {
+        const filePath = await getSessionFilePath(sessionId, workdir);
         await fs.unlink(filePath);
+        // Try to clean up empty project directory
+        const encoder = new PathEncoder();
+        const projectDir = await encoder.createProjectDirectory(workdir, SESSION_DIR);
+        try {
+            const files = await fs.readdir(projectDir.encodedPath);
+            if (files.length === 0) {
+                await fs.rmdir(projectDir.encodedPath);
+            }
+        }
+        catch {
+            // Ignore errors if directory is not empty or can't be removed
+        }
         return true;
     }
     catch (error) {
@@ -201,47 +325,101 @@ export async function deleteSession(sessionId, sessionDir) {
     }
 }
 /**
- * Clean up expired sessions older than the configured maximum age
+ * Clean up expired sessions older than 14 days based on file modification time
  *
  * @param workdir - Working directory to clean up sessions for
- * @param sessionDir - Optional custom directory for session storage (defaults to ~/.wave/sessions/)
  * @returns Promise that resolves to the number of sessions that were deleted
- * @throws {Error} When session directory cannot be accessed or sessions cannot be deleted
  */
-export async function cleanupExpiredSessions(workdir, sessionDir) {
+export async function cleanupExpiredSessionsFromJsonl(workdir) {
     // Do not perform cleanup operations in test environment
     if (process.env.NODE_ENV === "test") {
         return 0;
     }
-    const sessions = await listSessions(workdir, true, sessionDir);
-    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 {
+        const encoder = new PathEncoder();
+        const projectDir = await encoder.createProjectDirectory(workdir, SESSION_DIR);
+        const files = await fs.readdir(projectDir.encodedPath);
+        const now = new Date();
+        const maxAge = MAX_SESSION_AGE_DAYS * 24 * 60 * 60 * 1000; // Convert to milliseconds
+        let deletedCount = 0;
+        for (const file of files) {
+            if (!file.endsWith(".jsonl")) {
+                continue;
+            }
+            const filePath = join(projectDir.encodedPath, file);
             try {
-                await deleteSession(session.id, sessionDir);
-                deletedCount++;
+                const stat = await fs.stat(filePath);
+                const fileAge = now.getTime() - stat.mtime.getTime();
+                if (fileAge > maxAge) {
+                    await fs.unlink(filePath);
+                    deletedCount++;
+                }
             }
             catch {
-                // Skip failed deletions and continue processing other sessions
+                // Skip failed operations and continue processing other files
                 continue;
             }
         }
+        // Clean up empty project directory if no files remain
+        try {
+            const remainingFiles = await fs.readdir(projectDir.encodedPath);
+            if (remainingFiles.length === 0) {
+                await fs.rmdir(projectDir.encodedPath);
+            }
+        }
+        catch {
+            // Ignore errors if directory is not empty or can't be removed
+        }
+        return deletedCount;
+    }
+    catch {
+        // Return 0 if project directory doesn't exist or can't be accessed
+        return 0;
     }
-    return deletedCount;
 }
 /**
- * Check if a session exists in storage
+ * Clean up empty project directories in the session directory
+ */
+export async function cleanupEmptyProjectDirectories() {
+    // Do not perform cleanup operations in test environment
+    if (process.env.NODE_ENV === "test") {
+        return;
+    }
+    try {
+        const baseDir = SESSION_DIR;
+        const projectDirs = await fs.readdir(baseDir);
+        for (const projectDirName of projectDirs) {
+            const projectPath = join(baseDir, projectDirName);
+            const stat = await fs.stat(projectPath);
+            if (stat.isDirectory()) {
+                try {
+                    const files = await fs.readdir(projectPath);
+                    // If directory is empty, remove it
+                    if (files.length === 0) {
+                        await fs.rmdir(projectPath);
+                    }
+                }
+                catch {
+                    // Skip errors for directories we can't read or remove
+                    continue;
+                }
+            }
+        }
+    }
+    catch {
+        // Ignore errors if base directory doesn't exist or can't be accessed
+    }
+}
+/**
+ * Check if a session exists in JSONL storage (new approach)
  *
- * @param sessionId - Unique identifier for the session to check
- * @param sessionDir - Optional custom directory for session storage (defaults to ~/.wave/sessions/)
+ * @param sessionId - UUIDv6 session identifier
+ * @param workdir - Working directory for the session
  * @returns Promise that resolves to true if session exists, false otherwise
  */
-export async function sessionExists(sessionId, sessionDir) {
-    const filePath = getSessionFilePath(sessionId, sessionDir);
+export async function sessionExistsInJsonl(sessionId, workdir) {
     try {
+        const filePath = await getSessionFilePath(sessionId, workdir);
         await fs.access(filePath);
         return true;
     }

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

@@ -1 +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"}
+{"version":3,"file":"bashTool.d.ts","sourceRoot":"","sources":["../../src/tools/bashTool.ts"],"names":[],"mappings":"AAEA,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"}

package/dist/tools/bashTool.js

@@ -1,4 +1,5 @@
 import { spawn } from "child_process";
+import { logger } from "../utils/globalLogger.js";
 /**
  * Bash command execution tool - supports both foreground and background execution
  */
@@ -112,8 +113,8 @@ export const bashTool = {
                                     try {
                                         process.kill(-child.pid, "SIGKILL");
                                     }
-                                    catch {
-                                        // logger.error("Failed to force kill process:", killError);
+                                    catch (killError) {
+                                        logger.error("Failed to force kill process:", killError);
                                     }
                                 }
                             }, 1000);
@@ -128,8 +129,8 @@ export const bashTool = {
                                     }
                                 }, 1000);
                             }
-                            catch {
-                                // logger.error("Failed to kill child process:", directKillError);
+                            catch (directKillError) {
+                                logger.error("Failed to kill child process:", directKillError);
                             }
                         }
                     }

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

@@ -1 +1 @@
-{"version":3,"file":"deleteFileTool.d.ts","sourceRoot":"","sources":["../../src/tools/deleteFileTool.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,UAAU,EAA2B,MAAM,YAAY,CAAC;AAGtE;;GAEG;AACH,eAAO,MAAM,cAAc,EAAE,UAyE5B,CAAC"}
+{"version":3,"file":"deleteFileTool.d.ts","sourceRoot":"","sources":["../../src/tools/deleteFileTool.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,UAAU,EAA2B,MAAM,YAAY,CAAC;AAGtE;;GAEG;AACH,eAAO,MAAM,cAAc,EAAE,UAyE5B,CAAC"}

package/dist/tools/deleteFileTool.js

@@ -1,4 +1,5 @@
 import { unlink } from "fs/promises";
+import { logger } from "../utils/globalLogger.js";
 import { resolvePath, getDisplayPath } from "../utils/path.js";
 /**
  * Delete file tool plugin
@@ -38,7 +39,7 @@ export const deleteFileTool = {
             const filePath = resolvePath(targetFile, context.workdir);
             // Delete file
             await unlink(filePath);
-            // logger.debug(`Successfully deleted file: ${filePath}`);
+            logger.debug(`Successfully deleted file: ${filePath}`);
             return {
                 success: true,
                 content: `Successfully deleted file: ${targetFile}`,

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

@@ -1 +1 @@
-{"version":3,"file":"editTool.d.ts","sourceRoot":"","sources":["../../src/tools/editTool.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,UAAU,EAA2B,MAAM,YAAY,CAAC;AAetE;;GAEG;AACH,eAAO,MAAM,QAAQ,EAAE,UAqKtB,CAAC"}
+{"version":3,"file":"editTool.d.ts","sourceRoot":"","sources":["../../src/tools/editTool.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,UAAU,EAA2B,MAAM,YAAY,CAAC;AAetE;;GAEG;AACH,eAAO,MAAM,QAAQ,EAAE,UAqKtB,CAAC"}

package/dist/tools/editTool.js

@@ -1,4 +1,5 @@
 import { readFile, writeFile } from "fs/promises";
+import { logger } from "../utils/globalLogger.js";
 import { resolvePath, getDisplayPath } from "../utils/path.js";
 import { diffLines } from "diff";
 /**
@@ -138,7 +139,7 @@ export const editTool = {
             const shortResult = replaceAll
                 ? `Replaced ${replacementCount} instances`
                 : "Text replaced successfully";
-            // logger.debug(`Edit tool: ${shortResult}`);
+            logger.debug(`Edit tool: ${shortResult}`);
             return {
                 success: true,
                 content: shortResult,
@@ -151,7 +152,7 @@ export const editTool = {
         }
         catch (error) {
             const errorMessage = error instanceof Error ? error.message : String(error);
-            // logger.error(`Edit tool error: ${errorMessage}`);
+            logger.error(`Edit tool error: ${errorMessage}`);
             return {
                 success: false,
                 content: "",

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

@@ -1 +1 @@
-{"version":3,"file":"multiEditTool.d.ts","sourceRoot":"","sources":["../../src/tools/multiEditTool.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,UAAU,EAA2B,MAAM,YAAY,CAAC;AAwBtE;;GAEG;AACH,eAAO,MAAM,aAAa,EAAE,UAwO3B,CAAC"}
+{"version":3,"file":"multiEditTool.d.ts","sourceRoot":"","sources":["../../src/tools/multiEditTool.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,UAAU,EAA2B,MAAM,YAAY,CAAC;AAwBtE;;GAEG;AACH,eAAO,MAAM,aAAa,EAAE,UAwO3B,CAAC"}