wave-agent-sdk 0.0.1

package/dist/managers/messageManager.js

@@ -0,0 +1,265 @@
+import { randomUUID } from "crypto";
+import { addAssistantMessageToMessages, updateToolBlockInMessage, addErrorBlockToMessage, addDiffBlockToMessage, addUserMessageToMessages, extractUserInputHistory, addMemoryBlockToMessage, addCommandOutputMessage, updateCommandOutputInMessage, completeCommandInMessage, } from "../utils/messageOperations.js";
+import { cleanupExpiredSessions, getLatestSession, loadSession, saveSession, getSessionFilePath, } from "../services/session.js";
+export class MessageManager {
+    constructor(options) {
+        this.sessionId = randomUUID();
+        this.messages = [];
+        this.latestTotalTokens = 0;
+        this.userInputHistory = [];
+        this.sessionStartTime = new Date().toISOString();
+        this.workdir = options.workdir;
+        this.callbacks = options.callbacks;
+        this.logger = options.logger;
+    }
+    // Getter methods
+    getSessionId() {
+        return this.sessionId;
+    }
+    getMessages() {
+        return [...this.messages];
+    }
+    getlatestTotalTokens() {
+        return this.latestTotalTokens;
+    }
+    getUserInputHistory() {
+        return [...this.userInputHistory];
+    }
+    getTranscriptPath() {
+        return getSessionFilePath(this.sessionId);
+    }
+    // Setter methods, will trigger callbacks
+    setSessionId(sessionId) {
+        if (this.sessionId !== sessionId) {
+            this.sessionId = sessionId;
+            this.callbacks.onSessionIdChange?.(sessionId);
+        }
+    }
+    setMessages(messages) {
+        this.messages = [...messages];
+        this.callbacks.onMessagesChange?.([...messages]);
+    }
+    /**
+     * Save current session
+     */
+    async saveSession() {
+        try {
+            await saveSession(this.sessionId, this.messages, this.workdir, this.latestTotalTokens, this.sessionStartTime);
+        }
+        catch (error) {
+            this.logger?.error("Failed to save session:", error);
+        }
+    }
+    /**
+     * Handle session restoration logic
+     */
+    async handleSessionRestoration(restoreSessionId, continueLastSession) {
+        // Clean up expired sessions first
+        try {
+            await cleanupExpiredSessions(this.workdir);
+        }
+        catch (error) {
+            console.warn("Failed to cleanup expired sessions:", error);
+        }
+        if (!restoreSessionId && !continueLastSession) {
+            return;
+        }
+        try {
+            let sessionToRestore = null;
+            if (restoreSessionId) {
+                sessionToRestore = await loadSession(restoreSessionId);
+                if (!sessionToRestore) {
+                    console.error(`Session not found: ${restoreSessionId}`);
+                    process.exit(1);
+                }
+            }
+            else if (continueLastSession) {
+                sessionToRestore = await getLatestSession(this.workdir);
+                if (!sessionToRestore) {
+                    console.error(`No previous session found for workdir: ${this.workdir}`);
+                    process.exit(1);
+                }
+            }
+            if (sessionToRestore) {
+                console.log(`Restoring session: ${sessionToRestore.id}`);
+                // Initialize from session data
+                this.initializeFromSession(sessionToRestore.id, sessionToRestore.messages, sessionToRestore.metadata.latestTotalTokens);
+            }
+        }
+        catch (error) {
+            console.error("Failed to restore session:", error);
+            process.exit(1);
+        }
+    }
+    setlatestTotalTokens(latestTotalTokens) {
+        if (this.latestTotalTokens !== latestTotalTokens) {
+            this.latestTotalTokens = latestTotalTokens;
+            this.callbacks.onLatestTotalTokensChange?.(latestTotalTokens);
+        }
+    }
+    setUserInputHistory(userInputHistory) {
+        this.userInputHistory = [...userInputHistory];
+        this.callbacks.onUserInputHistoryChange?.(this.userInputHistory);
+    }
+    /**
+     * Clear messages and input history
+     */
+    clearMessages() {
+        this.setMessages([]);
+        this.setUserInputHistory([]);
+        this.setSessionId(randomUUID());
+        this.setlatestTotalTokens(0);
+        this.sessionStartTime = new Date().toISOString();
+    }
+    // Initialize state from session data
+    initializeFromSession(sessionId, messages, latestTotalTokens) {
+        this.setSessionId(sessionId);
+        this.setMessages([...messages]);
+        this.setlatestTotalTokens(latestTotalTokens);
+        // Extract user input history from session messages
+        this.setUserInputHistory(extractUserInputHistory(messages));
+    }
+    // Add to input history
+    addToInputHistory(input) {
+        // Avoid adding duplicate inputs
+        if (this.userInputHistory.length > 0 &&
+            this.userInputHistory[this.userInputHistory.length - 1] === input) {
+            return;
+        }
+        // Limit history records, keep the latest 100
+        this.setUserInputHistory([...this.userInputHistory, input].slice(-100));
+    }
+    // Clear input history
+    clearInputHistory() {
+        this.setUserInputHistory([]);
+    }
+    // Encapsulated message operation functions
+    addUserMessage(content, images) {
+        const newMessages = addUserMessageToMessages({
+            messages: this.messages,
+            content,
+            images,
+        });
+        this.setMessages(newMessages);
+        this.callbacks.onUserMessageAdded?.(content, images);
+    }
+    addCustomCommandMessage(commandName, content, originalInput) {
+        const newMessages = addUserMessageToMessages({
+            messages: this.messages,
+            content: "", // Empty content, as we will use CustomCommandBlock
+            customCommandBlock: {
+                type: "custom_command",
+                commandName,
+                content,
+                originalInput,
+            },
+        });
+        this.setMessages(newMessages);
+        this.callbacks.onUserMessageAdded?.(content);
+    }
+    addAssistantMessage(content, toolCalls) {
+        const newMessages = addAssistantMessageToMessages(this.messages, content, toolCalls);
+        this.setMessages(newMessages);
+        this.callbacks.onAssistantMessageAdded?.(content, toolCalls);
+    }
+    updateToolBlock(params) {
+        const newMessages = updateToolBlockInMessage({
+            messages: this.messages,
+            id: params.toolId,
+            parameters: params.args || "",
+            result: params.result,
+            success: params.success,
+            error: params.error,
+            isRunning: params.isRunning,
+            name: params.name,
+            shortResult: params.shortResult,
+            compactParams: params.compactParams,
+        });
+        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));
+    }
+    addErrorBlock(error) {
+        const newMessages = addErrorBlockToMessage({
+            messages: this.messages,
+            error,
+        });
+        this.setMessages(newMessages);
+        this.callbacks.onErrorBlockAdded?.(error);
+    }
+    /**
+     * Compress messages and update session, delete compressed messages, only keep compressed messages and subsequent messages
+     */
+    compressMessagesAndUpdateSession(insertIndex, compressedContent) {
+        const currentMessages = this.messages;
+        // Create compressed message
+        const compressMessage = {
+            role: "assistant",
+            blocks: [
+                {
+                    type: "compress",
+                    content: compressedContent,
+                },
+            ],
+        };
+        // Convert negative index to positive index
+        const actualIndex = insertIndex < 0 ? currentMessages.length + insertIndex : insertIndex;
+        // Build new message array: keep compressed message and all messages from actualIndex onwards
+        const newMessages = [
+            compressMessage,
+            ...currentMessages.slice(actualIndex),
+        ];
+        // Update sessionId
+        this.setSessionId(randomUUID());
+        // Set new message list
+        this.setMessages(newMessages);
+        // Trigger compression callback, insertIndex remains unchanged
+        this.callbacks.onCompressBlockAdded?.(insertIndex, compressedContent);
+    }
+    addMemoryBlock(content, success, type, storagePath) {
+        const newMessages = addMemoryBlockToMessage({
+            messages: this.messages,
+            content,
+            isSuccess: success,
+            memoryType: type,
+            storagePath,
+        });
+        this.setMessages(newMessages);
+        this.callbacks.onMemoryBlockAdded?.(content, success, type, storagePath);
+    }
+    // Bash command related message operations
+    addCommandOutputMessage(command) {
+        const updatedMessages = addCommandOutputMessage({
+            messages: this.messages,
+            command,
+        });
+        this.setMessages(updatedMessages);
+        this.callbacks.onAddCommandOutputMessage?.(command);
+    }
+    updateCommandOutputMessage(command, output) {
+        const updatedMessages = updateCommandOutputInMessage({
+            messages: this.messages,
+            command,
+            output,
+        });
+        this.setMessages(updatedMessages);
+        this.callbacks.onUpdateCommandOutputMessage?.(command, output);
+    }
+    completeCommandMessage(command, exitCode) {
+        const updatedMessages = completeCommandInMessage({
+            messages: this.messages,
+            command,
+            exitCode,
+        });
+        this.setMessages(updatedMessages);
+        this.callbacks.onCompleteCommandMessage?.(command, exitCode);
+    }
+}

package/dist/managers/skillManager.d.ts

@@ -0,0 +1,59 @@
+import type { SkillManagerOptions, SkillMetadata, Skill, SkillToolArgs, SkillInvocationContext } from "../types.js";
+import type { ToolPlugin } from "../tools/types.js";
+/**
+ * Manages skill discovery and loading
+ */
+export declare class SkillManager {
+    private personalSkillsPath;
+    private scanTimeout;
+    private logger?;
+    private skillMetadata;
+    private skillContent;
+    private initialized;
+    constructor(options?: SkillManagerOptions);
+    /**
+     * Initialize the skill manager by discovering available skills
+     */
+    initialize(): Promise<void>;
+    /**
+     * Get all available skills metadata
+     */
+    getAvailableSkills(): SkillMetadata[];
+    /**
+     * Load a specific skill by name
+     * Returns the skill content that was loaded during initialization
+     */
+    loadSkill(skillName: string): Promise<Skill | null>;
+    /**
+     * Discover skills in both personal and project directories
+     */
+    private discoverSkills;
+    /**
+     * Discover skills in a specific directory
+     */
+    private discoverSkillCollection;
+    /**
+     * Find all directories that could contain skills
+     */
+    private findSkillDirectories;
+    /**
+     * Create a tool plugin for registering with ToolManager
+     */
+    createTool(): ToolPlugin;
+    /**
+     * Execute a skill by name
+     */
+    executeSkill(args: SkillToolArgs): Promise<{
+        content: string;
+        context?: SkillInvocationContext;
+    }>;
+    /**
+     * Format skill content for output
+     */
+    private formatSkillContent;
+    /**
+     * Format available skills list for error messages
+     */
+    private formatAvailableSkills;
+}
+//# sourceMappingURL=skillManager.d.ts.map

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

@@ -0,0 +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,aAAa,CAAC;AACrB,OAAO,KAAK,EAAE,UAAU,EAAc,MAAM,mBAAmB,CAAC;AAGhE;;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,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;IACH,UAAU,IAAI,UAAU;IA4FxB;;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"}

package/dist/managers/skillManager.js

@@ -0,0 +1,317 @@
+import { readdir, stat } from "fs/promises";
+import { join } from "path";
+import { homedir } from "os";
+import { parseSkillFile, formatSkillError } from "../utils/skillParser.js";
+/**
+ * Manages skill discovery and loading
+ */
+export class SkillManager {
+    constructor(options = {}) {
+        this.skillMetadata = new Map();
+        this.skillContent = new Map();
+        this.initialized = false;
+        this.personalSkillsPath =
+            options.personalSkillsPath || join(homedir(), ".wave", "skills");
+        this.scanTimeout = options.scanTimeout || 5000;
+        this.logger = options.logger;
+    }
+    /**
+     * Initialize the skill manager by discovering available skills
+     */
+    async initialize() {
+        this.logger?.info("Initializing SkillManager...");
+        try {
+            // Clear existing data before discovery
+            this.skillMetadata.clear();
+            this.skillContent.clear();
+            const discovery = await this.discoverSkills();
+            // Store discovered skill metadata
+            discovery.personalSkills.forEach((skill, name) => {
+                this.skillMetadata.set(name, skill);
+            });
+            discovery.projectSkills.forEach((skill, name) => {
+                this.skillMetadata.set(name, skill);
+            });
+            // Log any discovery errors
+            if (discovery.errors.length > 0) {
+                this.logger?.warn(`Found ${discovery.errors.length} skill discovery errors`);
+                discovery.errors.forEach((error) => {
+                    this.logger?.warn(`Skill error in ${error.skillPath}: ${error.message}`);
+                });
+            }
+            this.initialized = true;
+            this.logger?.info(`SkillManager initialized with ${this.skillMetadata.size} skills`);
+        }
+        catch (error) {
+            this.logger?.error("Failed to initialize SkillManager:", error);
+            throw error;
+        }
+    }
+    /**
+     * Get all available skills metadata
+     */
+    getAvailableSkills() {
+        if (!this.initialized) {
+            throw new Error("SkillManager not initialized. Call initialize() first.");
+        }
+        return Array.from(this.skillMetadata.values());
+    }
+    /**
+     * Load a specific skill by name
+     * Returns the skill content that was loaded during initialization
+     */
+    async loadSkill(skillName) {
+        if (!this.initialized) {
+            throw new Error("SkillManager not initialized. Call initialize() first.");
+        }
+        // Return skill content that was loaded during initialization
+        const skill = this.skillContent.get(skillName);
+        if (skill) {
+            this.logger?.debug(`Skill '${skillName}' retrieved from loaded content`);
+            return skill;
+        }
+        this.logger?.debug(`Skill '${skillName}' not found`);
+        return null;
+    }
+    /**
+     * Discover skills in both personal and project directories
+     */
+    async discoverSkills() {
+        const personalCollection = await this.discoverSkillCollection(this.personalSkillsPath, "personal");
+        const projectCollection = await this.discoverSkillCollection(process.cwd(), "project");
+        return {
+            personalSkills: personalCollection.skills,
+            projectSkills: projectCollection.skills,
+            errors: [...personalCollection.errors, ...projectCollection.errors],
+        };
+    }
+    /**
+     * Discover skills in a specific directory
+     */
+    async discoverSkillCollection(basePath, type) {
+        const collection = {
+            type,
+            basePath,
+            skills: new Map(),
+            errors: [],
+        };
+        const skillsPath = type === "personal" ? basePath : join(basePath, ".wave", "skills");
+        try {
+            const skillDirs = await this.findSkillDirectories(skillsPath);
+            this.logger?.debug(`Found ${skillDirs.length} potential skill directories in ${skillsPath}`);
+            for (const skillDir of skillDirs) {
+                try {
+                    const skillFilePath = join(skillDir, "SKILL.md");
+                    // Check if SKILL.md exists
+                    try {
+                        await stat(skillFilePath);
+                    }
+                    catch {
+                        continue; // Skip directories without SKILL.md
+                    }
+                    const parsed = parseSkillFile(skillFilePath, {
+                        basePath: skillDir,
+                        validateMetadata: true,
+                    });
+                    if (parsed.isValid) {
+                        // Override the skill type with the collection type
+                        const skillMetadata = {
+                            ...parsed.skillMetadata,
+                            type,
+                        };
+                        // Create full skill object with content
+                        const skill = {
+                            name: parsed.skillMetadata.name,
+                            description: parsed.skillMetadata.description,
+                            type: type, // Use the collection type
+                            skillPath: parsed.skillMetadata.skillPath,
+                            content: parsed.content,
+                            frontmatter: parsed.frontmatter,
+                            isValid: parsed.isValid,
+                            errors: parsed.validationErrors,
+                        };
+                        collection.skills.set(skillMetadata.name, skillMetadata);
+                        // Store the full skill content in the manager's skillContent map
+                        this.skillContent.set(skillMetadata.name, skill);
+                    }
+                    else {
+                        collection.errors.push({
+                            skillPath: skillDir,
+                            message: parsed.validationErrors.join("; "),
+                        });
+                    }
+                }
+                catch (error) {
+                    collection.errors.push({
+                        skillPath: skillDir,
+                        message: `Failed to process skill: ${error instanceof Error ? error.message : String(error)}`,
+                    });
+                }
+            }
+        }
+        catch (error) {
+            this.logger?.debug(`Could not scan ${skillsPath}: ${error instanceof Error ? error.message : String(error)}`);
+            // Not an error - the directory might not exist yet
+        }
+        return collection;
+    }
+    /**
+     * Find all directories that could contain skills
+     */
+    async findSkillDirectories(skillsPath) {
+        const directories = [];
+        try {
+            const entries = await readdir(skillsPath, { withFileTypes: true });
+            for (const entry of entries) {
+                if (entry.isDirectory()) {
+                    directories.push(join(skillsPath, entry.name));
+                }
+            }
+        }
+        catch {
+            // Directory doesn't exist - return empty array
+        }
+        return directories;
+    }
+    /**
+     * Create a tool plugin for registering with ToolManager
+     */
+    createTool() {
+        // Initialize skill manager asynchronously
+        let initializationPromise = null;
+        const ensureInitialized = async () => {
+            if (!initializationPromise) {
+                initializationPromise = this.initialize();
+            }
+            await initializationPromise;
+        };
+        const getToolDescription = () => {
+            if (!this.initialized) {
+                return "Invoke a Wave skill by name. Skills are user-defined automation templates that can be personal or project-specific. Skills will be loaded during initialization.";
+            }
+            const availableSkills = this.getAvailableSkills();
+            if (availableSkills.length === 0) {
+                return "Invoke a Wave skill by name. Skills are user-defined automation templates that can be personal or project-specific. No skills are currently available.";
+            }
+            const skillList = availableSkills
+                .map((skill) => `• **${skill.name}** (${skill.type}): ${skill.description}`)
+                .join("\n");
+            return `Invoke a Wave skill by name. Skills are user-defined automation templates that can be personal or project-specific.\n\nAvailable skills:\n${skillList}`;
+        };
+        return {
+            name: "skill",
+            config: {
+                type: "function",
+                function: {
+                    name: "skill",
+                    description: getToolDescription(),
+                    parameters: {
+                        type: "object",
+                        properties: {
+                            skill_name: {
+                                type: "string",
+                                description: "Name of the skill to invoke",
+                                enum: this.initialized
+                                    ? this.getAvailableSkills().map((skill) => skill.name)
+                                    : [],
+                            },
+                        },
+                        required: ["skill_name"],
+                    },
+                },
+            },
+            execute: async (args) => {
+                try {
+                    // Ensure skill manager is initialized
+                    await ensureInitialized();
+                    // Validate arguments
+                    const skillName = args.skill_name;
+                    if (!skillName || typeof skillName !== "string") {
+                        return {
+                            success: false,
+                            content: "",
+                            error: "skill_name parameter is required and must be a string",
+                        };
+                    }
+                    // Execute the skill
+                    const result = await this.executeSkill({ skill_name: skillName });
+                    return {
+                        success: true,
+                        content: result.content,
+                        shortResult: `Invoked skill: ${skillName}`,
+                    };
+                }
+                catch (error) {
+                    return {
+                        success: false,
+                        content: "",
+                        error: error instanceof Error ? error.message : String(error),
+                    };
+                }
+            },
+            formatCompactParams: (params) => {
+                const skillName = params.skill_name;
+                return skillName || "unknown-skill";
+            },
+        };
+    }
+    /**
+     * Execute a skill by name
+     */
+    async executeSkill(args) {
+        const { skill_name } = args;
+        this.logger?.info(`Invoking skill: ${skill_name}`);
+        try {
+            // Load the skill
+            const skill = await this.loadSkill(skill_name);
+            if (!skill) {
+                return {
+                    content: `❌ **Skill not found**: "${skill_name}"\n\nAvailable skills:\n${this.formatAvailableSkills()}`,
+                };
+            }
+            if (!skill.isValid) {
+                const errorMsg = formatSkillError(skill.skillPath, skill.errors);
+                return {
+                    content: `❌ **Skill validation failed**:\n\n\`\`\`\n${errorMsg}\n\`\`\``,
+                };
+            }
+            // Return skill content with context
+            return {
+                content: this.formatSkillContent(skill),
+                context: {
+                    skillName: skill_name,
+                },
+            };
+        }
+        catch (error) {
+            this.logger?.error(`Failed to execute skill '${skill_name}':`, error);
+            return {
+                content: `❌ **Error executing skill**: ${error instanceof Error ? error.message : String(error)}`,
+            };
+        }
+    }
+    /**
+     * Format skill content for output
+     */
+    formatSkillContent(skill) {
+        const header = `🧠 **${skill.name}** (${skill.type} skill)\n\n`;
+        const description = `*${skill.description}*\n\n`;
+        const skillPath = `📁 Skill location: \`${skill.skillPath}\`\n\n`;
+        // Extract content after frontmatter
+        const contentMatch = skill.content.match(/^---\n[\s\S]*?\n---\n([\s\S]*)$/);
+        const mainContent = contentMatch ? contentMatch[1].trim() : skill.content;
+        return header + description + skillPath + mainContent;
+    }
+    /**
+     * Format available skills list for error messages
+     */
+    formatAvailableSkills() {
+        const skills = this.getAvailableSkills();
+        if (skills.length === 0) {
+            return "• No skills available\n\nTo create skills, see the Wave Skills documentation.";
+        }
+        return skills
+            .map((skill) => `• **${skill.name}** (${skill.type}): ${skill.description}`)
+            .join("\n");
+    }
+}