wave-agent-sdk 0.0.7 → 0.0.10

package/dist/managers/messageManager.js

@@ -1,17 +1,22 @@
-import { randomUUID } from "crypto";
-import { addAssistantMessageToMessages, updateToolBlockInMessage, addErrorBlockToMessage, addDiffBlockToMessage, addUserMessageToMessages, extractUserInputHistory, addMemoryBlockToMessage, addCommandOutputMessage, updateCommandOutputInMessage, completeCommandInMessage, addSubagentBlockToMessage, updateSubagentBlockInMessage, removeLastUserMessage, } from "../utils/messageOperations.js";
-import { cleanupExpiredSessions, getLatestSession, loadSession, saveSession, getSessionFilePath, } from "../services/session.js";
+import { addAssistantMessageToMessages, updateToolBlockInMessage, addErrorBlockToMessage, addUserMessageToMessages, extractUserInputHistory, addMemoryBlockToMessage, addCommandOutputMessage, updateCommandOutputInMessage, completeCommandInMessage, addSubagentBlockToMessage, updateSubagentBlockInMessage, removeLastUserMessage, } from "../utils/messageOperations.js";
+import { join } from "path";
+import { appendMessages, createSession, generateSessionId, SESSION_DIR, } from "../services/session.js";
+import { pathEncoder } from "../utils/pathEncoder.js";
 export class MessageManager {
     constructor(options) {
-        this.sessionId = randomUUID();
+        this.sessionId = generateSessionId();
         this.messages = [];
         this.latestTotalTokens = 0;
         this.userInputHistory = [];
-        this.sessionStartTime = new Date().toISOString();
         this.workdir = options.workdir;
+        this.encodedWorkdir = pathEncoder.encodeSync(this.workdir); // Cache encoded workdir
         this.callbacks = options.callbacks;
         this.logger = options.logger;
-        this.sessionDir = options.sessionDir;
+        this.savedMessageCount = 0; // Initialize saved message count tracker
+        this.sessionType = options.sessionType || "main";
+        this.subagentType = options.subagentType;
+        // Compute and cache the transcript path
+        this.transcriptPath = this.computeTranscriptPath();
     }
     // Getter methods
     getSessionId() {
@@ -26,70 +31,75 @@ export class MessageManager {
     getUserInputHistory() {
         return [...this.userInputHistory];
     }
+    getWorkdir() {
+        return this.workdir;
+    }
+    getSessionDir() {
+        return SESSION_DIR;
+    }
     getTranscriptPath() {
-        return getSessionFilePath(this.sessionId, this.sessionDir);
+        return this.transcriptPath;
+    }
+    /**
+     * Compute the transcript path using cached encoded workdir
+     * Called during construction and when sessionId changes
+     */
+    computeTranscriptPath() {
+        const baseDir = join(SESSION_DIR, this.encodedWorkdir);
+        // All sessions now go in the same directory
+        // Session type is determined by metadata, not file path
+        return join(baseDir, `${this.sessionId}.jsonl`);
     }
     // Setter methods, will trigger callbacks
     setSessionId(sessionId) {
         if (this.sessionId !== sessionId) {
             this.sessionId = sessionId;
+            // Reset saved message count for new session
+            this.savedMessageCount = 0;
+            // Recompute transcript path since session ID changed
+            this.transcriptPath = this.computeTranscriptPath();
             this.callbacks.onSessionIdChange?.(sessionId);
         }
     }
-    setMessages(messages) {
-        this.messages = [...messages];
-        this.callbacks.onMessagesChange?.([...messages]);
-    }
     /**
-     * Save current session
+     * Create session if needed (async helper)
      */
-    async saveSession() {
+    async createSessionIfNeeded() {
         try {
-            await saveSession(this.sessionId, this.messages, this.workdir, this.latestTotalTokens, this.sessionStartTime, this.sessionDir);
+            await createSession(this.sessionId, this.workdir, this.sessionType);
         }
         catch (error) {
-            this.logger?.error("Failed to save session:", error);
+            this.logger?.error("Failed to create session:", error);
         }
     }
+    setMessages(messages) {
+        this.messages = [...messages];
+        this.callbacks.onMessagesChange?.([...messages]);
+    }
     /**
-     * Handle session restoration logic
+     * Save current session
      */
-    async handleSessionRestoration(restoreSessionId, continueLastSession) {
-        // Clean up expired sessions first
-        try {
-            await cleanupExpiredSessions(this.workdir, this.sessionDir);
-        }
-        catch (error) {
-            this.logger?.warn("Failed to cleanup expired sessions:", error);
-        }
-        if (!restoreSessionId && !continueLastSession) {
-            return;
-        }
+    async saveSession() {
         try {
-            let sessionToRestore = null;
-            if (restoreSessionId) {
-                sessionToRestore = await loadSession(restoreSessionId, this.sessionDir);
-                if (!sessionToRestore) {
-                    console.error(`Session not found: ${restoreSessionId}`);
-                    process.exit(1);
-                }
-            }
-            else if (continueLastSession) {
-                sessionToRestore = await getLatestSession(this.workdir, this.sessionDir);
-                if (!sessionToRestore) {
-                    console.error(`No previous session found for workdir: ${this.workdir}`);
-                    process.exit(1);
-                }
+            // Only save messages that haven't been saved yet
+            const unsavedMessages = this.messages.slice(this.savedMessageCount);
+            if (unsavedMessages.length === 0) {
+                // No new messages to save
+                return;
             }
-            if (sessionToRestore) {
-                console.log(`Restoring session: ${sessionToRestore.id}`);
-                // Initialize from session data
-                this.initializeFromSession(sessionToRestore.id, sessionToRestore.messages, sessionToRestore.metadata.latestTotalTokens);
+            // Create session if needed (only when we have messages to save)
+            if (this.savedMessageCount === 0) {
+                // This is the first time saving messages, so create the session
+                await this.createSessionIfNeeded();
             }
+            // Use JSONL format for new sessions
+            await appendMessages(this.sessionId, unsavedMessages, // Only append new messages
+            this.workdir, this.sessionType);
+            // Update the saved message count
+            this.savedMessageCount = this.messages.length;
         }
         catch (error) {
-            console.error("Failed to restore session:", error);
-            process.exit(1);
+            this.logger?.error("Failed to save session:", error);
         }
     }
     setlatestTotalTokens(latestTotalTokens) {
@@ -108,17 +118,20 @@ export class MessageManager {
     clearMessages() {
         this.setMessages([]);
         this.setUserInputHistory([]);
-        this.setSessionId(randomUUID());
+        this.setSessionId(generateSessionId());
         this.setlatestTotalTokens(0);
-        this.sessionStartTime = new Date().toISOString();
+        this.savedMessageCount = 0; // Reset saved message count
     }
     // Initialize state from session data
-    initializeFromSession(sessionId, messages, latestTotalTokens) {
-        this.setSessionId(sessionId);
-        this.setMessages([...messages]);
-        this.setlatestTotalTokens(latestTotalTokens);
+    initializeFromSession(sessionData) {
+        this.setSessionId(sessionData.id);
+        this.setMessages([...sessionData.messages]);
+        this.setlatestTotalTokens(sessionData.metadata.latestTotalTokens);
         // Extract user input history from session messages
-        this.setUserInputHistory(extractUserInputHistory(messages));
+        this.setUserInputHistory(extractUserInputHistory(sessionData.messages));
+        // Set saved message count to the number of loaded messages since they're already saved
+        // This must be done after setSessionId which resets it to 0
+        this.savedMessageCount = sessionData.messages.length;
     }
     // Add to input history
     addToInputHistory(input) {
@@ -142,11 +155,42 @@ export class MessageManager {
         });
         this.setMessages(newMessages);
         this.callbacks.onUserMessageAdded?.(params);
+        // Note: Subagent-specific callbacks are now handled by SubagentManager
     }
-    addAssistantMessage(content, toolCalls, usage) {
-        const newMessages = addAssistantMessageToMessages(this.messages, content, toolCalls, usage);
+    addAssistantMessage(content, toolCalls, usage, additionalFields) {
+        const additionalFieldsRecord = additionalFields
+            ? Object.fromEntries(Object.entries(additionalFields).filter(([, value]) => value !== undefined))
+            : undefined;
+        const newMessages = addAssistantMessageToMessages(this.messages, content, toolCalls, usage, additionalFieldsRecord);
         this.setMessages(newMessages);
-        this.callbacks.onAssistantMessageAdded?.(content, toolCalls);
+        this.callbacks.onAssistantMessageAdded?.();
+        // Note: Subagent-specific callbacks are now handled by SubagentManager
+    }
+    mergeAssistantAdditionalFields(additionalFields) {
+        if (!additionalFields || Object.keys(additionalFields).length === 0) {
+            return;
+        }
+        const newMessages = [...this.messages];
+        for (let i = newMessages.length - 1; i >= 0; i--) {
+            const message = newMessages[i];
+            if (message.role === "assistant") {
+                const mergedAdditionalFields = {
+                    ...(message.additionalFields || {}),
+                };
+                for (const [key, value] of Object.entries(additionalFields)) {
+                    if (value === undefined) {
+                        continue;
+                    }
+                    mergedAdditionalFields[key] = value;
+                }
+                if (Object.keys(mergedAdditionalFields).length === 0) {
+                    return;
+                }
+                message.additionalFields = mergedAdditionalFields;
+                this.setMessages(newMessages);
+                return;
+            }
+        }
     }
     updateToolBlock(params) {
         const newMessages = updateToolBlockInMessage({
@@ -156,23 +200,16 @@ export class MessageManager {
             result: params.result,
             success: params.success,
             error: params.error,
-            isRunning: params.isRunning,
+            stage: params.stage,
             name: params.name,
             shortResult: params.shortResult,
             images: params.images,
             compactParams: params.compactParams,
+            parametersChunk: params.parametersChunk,
         });
         this.setMessages(newMessages);
         this.callbacks.onToolBlockUpdated?.(params);
-    }
-    addDiffBlock(filePath, diffResult) {
-        const newMessages = addDiffBlockToMessage({
-            messages: this.messages,
-            path: filePath,
-            diffResult,
-        });
-        this.setMessages(newMessages);
-        this.callbacks.onDiffBlockAdded?.(filePath, JSON.stringify(diffResult));
+        // Note: Subagent-specific callbacks are now handled by SubagentManager
     }
     addErrorBlock(error) {
         const newMessages = addErrorBlockToMessage({
@@ -185,7 +222,7 @@ export class MessageManager {
     /**
      * Compress messages and update session, delete compressed messages, only keep compressed messages and subsequent messages
      */
-    compressMessagesAndUpdateSession(insertIndex, compressedContent) {
+    compressMessagesAndUpdateSession(insertIndex, compressedContent, usage) {
         const currentMessages = this.messages;
         // Create compressed message
         const compressMessage = {
@@ -194,8 +231,10 @@ export class MessageManager {
                 {
                     type: "compress",
                     content: compressedContent,
+                    sessionId: this.sessionId,
                 },
             ],
+            ...(usage && { usage }),
         };
         // Convert negative index to positive index
         const actualIndex = insertIndex < 0 ? currentMessages.length + insertIndex : insertIndex;
@@ -205,7 +244,7 @@ export class MessageManager {
             ...currentMessages.slice(actualIndex),
         ];
         // Update sessionId
-        this.setSessionId(randomUUID());
+        this.setSessionId(generateSessionId());
         // Set new message list
         this.setMessages(newMessages);
         // Trigger compression callback, insertIndex remains unchanged
@@ -250,13 +289,14 @@ export class MessageManager {
         this.callbacks.onCompleteCommandMessage?.(command, exitCode);
     }
     // Subagent block methods
-    addSubagentBlock(subagentId, subagentName, status = "active", subagentMessages = [], parameters) {
+    addSubagentBlock(subagentId, subagentName, sessionId, configuration, status = "active", parameters) {
         const params = {
             messages: this.messages,
             subagentId,
             subagentName,
+            sessionId,
             status,
-            subagentMessages,
+            configuration,
         };
         const updatedMessages = addSubagentBlockToMessage(params);
         this.setMessages(updatedMessages);
@@ -269,9 +309,8 @@ export class MessageManager {
             messages: this.messages,
             subagentId,
             status: updates.status || "active",
-            subagentMessages: updates.messages || [],
         };
-        this.callbacks.onSubAgentBlockUpdated?.(params.subagentId, params.messages, params.status);
+        this.callbacks.onSubAgentBlockUpdated?.(params.subagentId, params.status);
     }
     /**
      * Trigger usage change callback with all usage data from assistant messages
@@ -285,6 +324,78 @@ export class MessageManager {
         }
         this.callbacks.onUsagesChange?.(usages);
     }
+    /**
+     * Update the current assistant message content during streaming
+     * This method updates the last assistant message's content without creating a new message
+     * FR-001: Tracks and provides both chunk (new content) and accumulated (total content)
+     */
+    updateCurrentMessageContent(newAccumulatedContent) {
+        if (this.messages.length === 0)
+            return;
+        const lastMessage = this.messages[this.messages.length - 1];
+        if (lastMessage.role !== "assistant")
+            return;
+        // Get the current content to calculate the chunk
+        const textBlockIndex = lastMessage.blocks.findIndex((block) => block.type === "text");
+        const currentContent = textBlockIndex >= 0
+            ? lastMessage.blocks[textBlockIndex].content || ""
+            : "";
+        // Calculate the chunk (new content since last update)
+        const chunk = newAccumulatedContent.slice(currentContent.length);
+        if (textBlockIndex >= 0) {
+            // Update existing text block
+            lastMessage.blocks[textBlockIndex] = {
+                type: "text",
+                content: newAccumulatedContent,
+            };
+        }
+        else {
+            // Add new text block if none exists
+            lastMessage.blocks.push({
+                type: "text",
+                content: newAccumulatedContent,
+            });
+        }
+        // FR-001: Trigger callbacks with chunk and accumulated content
+        this.callbacks.onAssistantContentUpdated?.(chunk, newAccumulatedContent);
+        // Note: Subagent-specific callbacks are now handled by SubagentManager
+        this.callbacks.onMessagesChange?.([...this.messages]); // Still need to notify of changes
+    }
+    /**
+     * Update the current assistant message reasoning during streaming
+     * This method updates the last assistant message's reasoning content without creating a new message
+     */
+    updateCurrentMessageReasoning(newAccumulatedReasoning) {
+        if (this.messages.length === 0)
+            return;
+        const lastMessage = this.messages[this.messages.length - 1];
+        if (lastMessage.role !== "assistant")
+            return;
+        // Get the current reasoning content to calculate the chunk
+        const reasoningBlockIndex = lastMessage.blocks.findIndex((block) => block.type === "reasoning");
+        const currentReasoning = reasoningBlockIndex >= 0
+            ? lastMessage.blocks[reasoningBlockIndex].content || ""
+            : "";
+        // Calculate the chunk (new content since last update)
+        const chunk = newAccumulatedReasoning.slice(currentReasoning.length);
+        if (reasoningBlockIndex >= 0) {
+            // Update existing reasoning block
+            lastMessage.blocks[reasoningBlockIndex] = {
+                type: "reasoning",
+                content: newAccumulatedReasoning,
+            };
+        }
+        else {
+            // Add new reasoning block if none exists
+            lastMessage.blocks.push({
+                type: "reasoning",
+                content: newAccumulatedReasoning,
+            });
+        }
+        // Trigger callbacks with chunk and accumulated reasoning content
+        this.callbacks.onAssistantReasoningUpdated?.(chunk, newAccumulatedReasoning);
+        this.callbacks.onMessagesChange?.([...this.messages]); // Still need to notify of changes
+    }
     /**
      * Remove the last user message from the conversation
      * Used for hook error handling when the user prompt needs to be erased

package/dist/managers/permissionManager.d.ts

@@ -0,0 +1,66 @@
+/**
+ * Permission Manager for handling tool permission checks
+ *
+ * This manager provides utilities for checking permissions before tool execution.
+ * It implements the permission logic for different modes (default vs bypass) and
+ * handles custom callback integration.
+ */
+import type { PermissionDecision, ToolPermissionContext, PermissionCallback, PermissionMode } from "../types/permissions.js";
+import type { Logger } from "../types/index.js";
+export interface PermissionManagerOptions {
+    /** Logger for debugging permission decisions */
+    logger?: Logger;
+    /** Configured default permission mode from settings */
+    configuredDefaultMode?: PermissionMode;
+    /** Allowed rules from settings */
+    allowedRules?: string[];
+}
+export declare class PermissionManager {
+    private logger?;
+    private configuredDefaultMode?;
+    private allowedRules;
+    private onConfiguredDefaultModeChange?;
+    constructor(options?: PermissionManagerOptions);
+    /**
+     * Set a callback to be notified when the effective permission mode changes due to configuration updates
+     */
+    setOnConfiguredDefaultModeChange(callback: (mode: PermissionMode) => void): void;
+    /**
+     * Update the configured default mode (e.g., when configuration reloads)
+     */
+    updateConfiguredDefaultMode(defaultMode?: PermissionMode): void;
+    /**
+     * Get all currently allowed rules
+     */
+    getAllowedRules(): string[];
+    /**
+     * Update the allowed rules (e.g., when configuration reloads)
+     */
+    updateAllowedRules(rules: string[]): void;
+    /**
+     * Get the current effective permission mode for tool execution context
+     */
+    getCurrentEffectiveMode(cliPermissionMode?: PermissionMode): PermissionMode;
+    /**
+     * Resolve the effective permission mode based on CLI override and configured default
+     */
+    resolveEffectivePermissionMode(cliPermissionMode?: PermissionMode): PermissionMode;
+    /**
+     * Check if a tool execution requires permission and handle the authorization flow
+     * Called by individual tools after validation/diff, before real operation
+     */
+    checkPermission(context: ToolPermissionContext): Promise<PermissionDecision>;
+    /**
+     * Determine if a tool requires permission checks based on its name
+     */
+    isRestrictedTool(toolName: string): boolean;
+    /**
+     * Helper method to create a permission context for CLI integration
+     */
+    createContext(toolName: string, permissionMode: PermissionMode, callback?: PermissionCallback, toolInput?: Record<string, unknown>): ToolPermissionContext;
+    /**
+     * Check if a tool call is allowed by persistent rules
+     */
+    private isAllowedByRule;
+}
+//# sourceMappingURL=permissionManager.d.ts.map

package/dist/managers/permissionManager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"permissionManager.d.ts","sourceRoot":"","sources":["../../src/managers/permissionManager.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EACV,kBAAkB,EAClB,qBAAqB,EACrB,kBAAkB,EAClB,cAAc,EACf,MAAM,yBAAyB,CAAC;AAEjC,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAEhD,MAAM,WAAW,wBAAwB;IACvC,gDAAgD;IAChD,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,uDAAuD;IACvD,qBAAqB,CAAC,EAAE,cAAc,CAAC;IACvC,kCAAkC;IAClC,YAAY,CAAC,EAAE,MAAM,EAAE,CAAC;CACzB;AAED,qBAAa,iBAAiB;IAC5B,OAAO,CAAC,MAAM,CAAC,CAAS;IACxB,OAAO,CAAC,qBAAqB,CAAC,CAAiB;IAC/C,OAAO,CAAC,YAAY,CAAgB;IACpC,OAAO,CAAC,6BAA6B,CAAC,CAAiC;gBAE3D,OAAO,GAAE,wBAA6B;IAMlD;;OAEG;IACI,gCAAgC,CACrC,QAAQ,EAAE,CAAC,IAAI,EAAE,cAAc,KAAK,IAAI,GACvC,IAAI;IAIP;;OAEG;IACH,2BAA2B,CAAC,WAAW,CAAC,EAAE,cAAc,GAAG,IAAI;IAyB/D;;OAEG;IACI,eAAe,IAAI,MAAM,EAAE;IAIlC;;OAEG;IACH,kBAAkB,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,IAAI;IAOzC;;OAEG;IACH,uBAAuB,CAAC,iBAAiB,CAAC,EAAE,cAAc,GAAG,cAAc;IAI3E;;OAEG;IACH,8BAA8B,CAC5B,iBAAiB,CAAC,EAAE,cAAc,GACjC,cAAc;IAuBjB;;;OAGG;IACG,eAAe,CACnB,OAAO,EAAE,qBAAqB,GAC7B,OAAO,CAAC,kBAAkB,CAAC;IAqF9B;;OAEG;IACH,gBAAgB,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO;IAW3C;;OAEG;IACH,aAAa,CACX,QAAQ,EAAE,MAAM,EAChB,cAAc,EAAE,cAAc,EAC9B,QAAQ,CAAC,EAAE,kBAAkB,EAC7B,SAAS,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAClC,qBAAqB;IAkBxB;;OAEG;IACH,OAAO,CAAC,eAAe;CAcxB"}

package/dist/managers/permissionManager.js

@@ -0,0 +1,208 @@
+/**
+ * Permission Manager for handling tool permission checks
+ *
+ * This manager provides utilities for checking permissions before tool execution.
+ * It implements the permission logic for different modes (default vs bypass) and
+ * handles custom callback integration.
+ */
+import { RESTRICTED_TOOLS } from "../types/permissions.js";
+export class PermissionManager {
+    constructor(options = {}) {
+        this.allowedRules = [];
+        this.logger = options.logger;
+        this.configuredDefaultMode = options.configuredDefaultMode;
+        this.allowedRules = options.allowedRules || [];
+    }
+    /**
+     * Set a callback to be notified when the effective permission mode changes due to configuration updates
+     */
+    setOnConfiguredDefaultModeChange(callback) {
+        this.onConfiguredDefaultModeChange = callback;
+    }
+    /**
+     * Update the configured default mode (e.g., when configuration reloads)
+     */
+    updateConfiguredDefaultMode(defaultMode) {
+        const oldEffectiveMode = this.getCurrentEffectiveMode();
+        this.logger?.debug("Updating configured default permission mode", {
+            previous: this.configuredDefaultMode,
+            new: defaultMode,
+        });
+        this.configuredDefaultMode = defaultMode;
+        const newEffectiveMode = this.getCurrentEffectiveMode();
+        if (oldEffectiveMode !== newEffectiveMode &&
+            this.onConfiguredDefaultModeChange) {
+            this.logger?.debug("Effective permission mode changed due to configuration update", {
+                oldMode: oldEffectiveMode,
+                newMode: newEffectiveMode,
+            });
+            this.onConfiguredDefaultModeChange(newEffectiveMode);
+        }
+    }
+    /**
+     * Get all currently allowed rules
+     */
+    getAllowedRules() {
+        return [...this.allowedRules];
+    }
+    /**
+     * Update the allowed rules (e.g., when configuration reloads)
+     */
+    updateAllowedRules(rules) {
+        this.logger?.debug("Updating allowed permission rules", {
+            count: rules.length,
+        });
+        this.allowedRules = rules;
+    }
+    /**
+     * Get the current effective permission mode for tool execution context
+     */
+    getCurrentEffectiveMode(cliPermissionMode) {
+        return this.resolveEffectivePermissionMode(cliPermissionMode);
+    }
+    /**
+     * Resolve the effective permission mode based on CLI override and configured default
+     */
+    resolveEffectivePermissionMode(cliPermissionMode) {
+        // CLI override takes highest precedence
+        if (cliPermissionMode !== undefined) {
+            this.logger?.debug("Using CLI permission mode override", {
+                cliMode: cliPermissionMode,
+                configuredDefault: this.configuredDefaultMode,
+            });
+            return cliPermissionMode;
+        }
+        // Use configured default mode if available
+        if (this.configuredDefaultMode !== undefined) {
+            this.logger?.debug("Using configured default permission mode", {
+                configuredDefault: this.configuredDefaultMode,
+            });
+            return this.configuredDefaultMode;
+        }
+        // Fall back to system default
+        this.logger?.debug("Using system default permission mode");
+        return "default";
+    }
+    /**
+     * Check if a tool execution requires permission and handle the authorization flow
+     * Called by individual tools after validation/diff, before real operation
+     */
+    async checkPermission(context) {
+        this.logger?.debug("Checking permission for tool", {
+            toolName: context.toolName,
+            permissionMode: context.permissionMode,
+            hasCallback: !!context.canUseToolCallback,
+        });
+        // 1. If bypassPermissions mode, always allow
+        if (context.permissionMode === "bypassPermissions") {
+            this.logger?.debug("Permission bypassed for tool", {
+                toolName: context.toolName,
+            });
+            return { behavior: "allow" };
+        }
+        // 1.1 If acceptEdits mode, allow Edit, MultiEdit, Delete, Write
+        if (context.permissionMode === "acceptEdits") {
+            const autoAcceptedTools = ["Edit", "MultiEdit", "Delete", "Write"];
+            if (autoAcceptedTools.includes(context.toolName)) {
+                this.logger?.debug("Permission automatically accepted for tool in acceptEdits mode", {
+                    toolName: context.toolName,
+                });
+                return { behavior: "allow" };
+            }
+        }
+        // 1.2 Check if tool call matches any allowed rule
+        if (this.isAllowedByRule(context)) {
+            this.logger?.debug("Permission allowed by persistent rule", {
+                toolName: context.toolName,
+            });
+            return { behavior: "allow" };
+        }
+        // 2. If not a restricted tool, always allow
+        if (!this.isRestrictedTool(context.toolName)) {
+            this.logger?.debug("Tool is not restricted, allowing", {
+                toolName: context.toolName,
+            });
+            return { behavior: "allow" };
+        }
+        // 3. If custom callback provided, call it and return result
+        if (context.canUseToolCallback) {
+            try {
+                this.logger?.debug("Calling custom permission callback for tool", {
+                    toolName: context.toolName,
+                });
+                const decision = await context.canUseToolCallback(context);
+                this.logger?.debug("Custom callback returned decision", {
+                    toolName: context.toolName,
+                    decision,
+                });
+                return decision;
+            }
+            catch (error) {
+                const errorMessage = error instanceof Error ? error.message : String(error);
+                this.logger?.error("Error in permission callback", {
+                    toolName: context.toolName,
+                    error: errorMessage,
+                });
+                return {
+                    behavior: "deny",
+                    message: "Error in permission callback",
+                };
+            }
+        }
+        // 4. For default mode on restricted tools without callback, integrate with CLI confirmation
+        // Note: CLI confirmation integration will be implemented in Phase 2
+        this.logger?.warn("No permission callback provided for restricted tool in default mode", {
+            toolName: context.toolName,
+        });
+        return {
+            behavior: "deny",
+            message: `Tool '${context.toolName}' requires permission approval. No permission callback configured.`,
+        };
+    }
+    /**
+     * Determine if a tool requires permission checks based on its name
+     */
+    isRestrictedTool(toolName) {
+        const isRestricted = RESTRICTED_TOOLS.includes(toolName);
+        this.logger?.debug("Checking if tool is restricted", {
+            toolName,
+            isRestricted,
+        });
+        return isRestricted;
+    }
+    /**
+     * Helper method to create a permission context for CLI integration
+     */
+    createContext(toolName, permissionMode, callback, toolInput) {
+        const context = {
+            toolName,
+            permissionMode,
+            canUseToolCallback: callback,
+            toolInput,
+        };
+        this.logger?.debug("Created permission context", {
+            toolName,
+            permissionMode,
+            hasCallback: !!callback,
+            hasToolInput: !!toolInput,
+        });
+        return context;
+    }
+    /**
+     * Check if a tool call is allowed by persistent rules
+     */
+    isAllowedByRule(context) {
+        if (context.toolName === "Bash" && context.toolInput?.command) {
+            const action = `Bash(${context.toolInput.command})`;
+            return this.allowedRules.some((rule) => {
+                if (rule.endsWith(":*)")) {
+                    const prefix = rule.slice(0, -3);
+                    return action.startsWith(prefix);
+                }
+                return action === rule;
+            });
+        }
+        // Add other tools if needed in the future
+        return false;
+    }
+}

package/dist/managers/skillManager.d.ts

@@ -6,6 +6,7 @@ export declare class SkillManager {
     private personalSkillsPath;
     private scanTimeout;
     private logger?;
+    private workdir;
     private skillMetadata;
     private skillContent;
     private initialized;

package/dist/managers/skillManager.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"skillManager.d.ts","sourceRoot":"","sources":["../../src/managers/skillManager.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EACV,mBAAmB,EACnB,aAAa,EACb,KAAK,EAGL,aAAa,EACb,sBAAsB,EAEvB,MAAM,mBAAmB,CAAC;AAG3B;;GAEG;AACH,qBAAa,YAAY;IACvB,OAAO,CAAC,kBAAkB,CAAS;IACnC,OAAO,CAAC,WAAW,CAAS;IAC5B,OAAO,CAAC,MAAM,CAAC,CAAS;IAExB,OAAO,CAAC,aAAa,CAAoC;IACzD,OAAO,CAAC,YAAY,CAA4B;IAChD,OAAO,CAAC,WAAW,CAAS;gBAEhB,OAAO,GAAE,mBAAwB;IAO7C;;OAEG;IACG,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAwCjC;;OAEG;IACH,aAAa,IAAI,OAAO;IAIxB;;OAEG;IACH,kBAAkB,IAAI,aAAa,EAAE;IAQrC;;;OAGG;IACG,SAAS,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,KAAK,GAAG,IAAI,CAAC;IAgBzD;;OAEG;YACW,cAAc;IAkB5B;;OAEG;YACW,uBAAuB;IAiFrC;;OAEG;YACW,oBAAoB;IAkBlC;;OAEG;IACG,YAAY,CAChB,IAAI,EAAE,aAAa,GAClB,OAAO,CAAC;QAAE,OAAO,EAAE,MAAM,CAAC;QAAC,OAAO,CAAC,EAAE,sBAAsB,CAAA;KAAE,CAAC;IAqCjE;;OAEG;IACH,OAAO,CAAC,kBAAkB;IAY1B;;OAEG;IACH,OAAO,CAAC,qBAAqB;CAa9B"}
+{"version":3,"file":"skillManager.d.ts","sourceRoot":"","sources":["../../src/managers/skillManager.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EACV,mBAAmB,EACnB,aAAa,EACb,KAAK,EAGL,aAAa,EACb,sBAAsB,EAEvB,MAAM,mBAAmB,CAAC;AAG3B;;GAEG;AACH,qBAAa,YAAY;IACvB,OAAO,CAAC,kBAAkB,CAAS;IACnC,OAAO,CAAC,WAAW,CAAS;IAC5B,OAAO,CAAC,MAAM,CAAC,CAAS;IACxB,OAAO,CAAC,OAAO,CAAS;IAExB,OAAO,CAAC,aAAa,CAAoC;IACzD,OAAO,CAAC,YAAY,CAA4B;IAChD,OAAO,CAAC,WAAW,CAAS;gBAEhB,OAAO,GAAE,mBAAwB;IAQ7C;;OAEG;IACG,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAwCjC;;OAEG;IACH,aAAa,IAAI,OAAO;IAIxB;;OAEG;IACH,kBAAkB,IAAI,aAAa,EAAE;IAQrC;;;OAGG;IACG,SAAS,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,KAAK,GAAG,IAAI,CAAC;IAgBzD;;OAEG;YACW,cAAc;IAkB5B;;OAEG;YACW,uBAAuB;IAiFrC;;OAEG;YACW,oBAAoB;IAkBlC;;OAEG;IACG,YAAY,CAChB,IAAI,EAAE,aAAa,GAClB,OAAO,CAAC;QAAE,OAAO,EAAE,MAAM,CAAC;QAAC,OAAO,CAAC,EAAE,sBAAsB,CAAA;KAAE,CAAC;IAqCjE;;OAEG;IACH,OAAO,CAAC,kBAAkB;IAY1B;;OAEG;IACH,OAAO,CAAC,qBAAqB;CAa9B"}