apexbot 1.0.4 → 1.0.6

package/dist/agent/agentManager.js

@@ -12,26 +12,34 @@ const toolExecutor_1 = require("./toolExecutor");
 class AgentManager {
     config = null;
     googleClient = null;
-    defaultSystemPrompt = `You are ApexBot, a helpful AI assistant running locally via Ollama. You are 100% free, private, and self-hosted.
+    defaultSystemPrompt = `You are ApexBot, an autonomous AI assistant like Claude Code. You can execute real actions on the user's computer.
 
-Your goal is to act as a fully autonomous agent, not just a chatbot. Follow these principles:
+## CORE PRINCIPLES
+1. **ACT, DON'T EXPLAIN** - When user asks for something, DO IT using tools. Don't explain how to do it.
+2. **BE AUTONOMOUS** - Make decisions and execute actions automatically
+3. **BE HELPFUL** - Provide direct answers and results, not tutorials
 
-1. **EXPLORE:** Analyze code and context thoroughly before responding.
-2. **PLAN:** Outline a clear plan before implementing changes.
-3. **ACT:** Provide complete, working code without placeholders like "// ... rest of code".
-4. **VERIFY:** Test your suggestions mentally and point out edge cases.
+## CAPABILITIES
+- Execute shell commands
+- Read/write/edit files
+- Get weather forecasts
+- Set reminders and timers
+- Control Spotify playback
+- Manage Obsidian notes
+- Search the web
+- Do math calculations
+- Get system information
 
-CODING STANDARDS:
-- TypeScript / Node.js with strict typing
-- Modular, clean, modern ES6+ syntax
-- Explicit error handling
-- Safety first for financial/crypto logic (arbitrage, Kelly criterion)
+## RESPONSE STYLE
+- Be concise and direct
+- Show results, not code tutorials
+- Use natural language to explain results
+- If something fails, explain why simply
 
-INTERACTION STYLE:
-- Be direct and actionable
-- Proactively identify issues and offer fixes
-- Keep responses concise but complete
-- Start with context analysis when working with code
+## LANGUAGE
+- Respond in the same language as the user
+- If user writes in Polish, respond in Polish
+- If user writes in English, respond in English
 
 You are running locally on the user's machine. No data leaves their computer. You are free, private, and open-source.`;
     constructor(config) {
@@ -103,12 +111,18 @@ You are running locally on the user's machine. No data leaves their computer. Yo
             if (this.config.enableTools) {
                 const toolCalls = (0, toolExecutor_1.parseToolCalls)(response.text);
                 if (toolCalls.length > 0) {
-                    console.log(`[Agent] Found ${toolCalls.length} tool calls`);
+                    console.log(`[Agent] Found ${toolCalls.length} tool calls:`, toolCalls.map(t => t.name));
                     // Build tool context
-                    const context = (0, toolExecutor_1.buildToolContext)(session.id, message.userId || 'unknown', message.channel, { workspaceDir: process.cwd() });
+                    const context = (0, toolExecutor_1.buildToolContext)(session.id, message.userId || message.from || 'unknown', message.channel, { workspaceDir: process.cwd() });
                     // Execute tools
                     const toolResults = await (0, toolExecutor_1.executeToolCalls)(toolCalls, context);
                     response.toolCalls = toolResults;
+                    // Log results
+                    for (const { call, result } of toolResults) {
+                        console.log(`[Agent] Tool ${call.name}: ${result.success ? 'SUCCESS' : 'FAILED'}`);
+                        if (!result.success)
+                            console.log(`[Agent] Error: ${result.error}`);
+                    }
                     // Format results and continue conversation
                     const resultsText = (0, toolExecutor_1.formatToolResults)(toolResults);
                     if (resultsText) {
@@ -116,7 +130,7 @@ You are running locally on the user's machine. No data leaves their computer. Yo
                         const followUpHistory = [
                             ...history,
                             { role: 'assistant', content: response.text, timestamp: Date.now() },
-                            { role: 'user', content: `Tool results:\n${resultsText}\n\nPlease continue based on these results.`, timestamp: Date.now() },
+                            { role: 'user', content: `[TOOL EXECUTION COMPLETE]\n\nResults:\n${resultsText}\n\nNow provide a natural language response to the user summarizing these results. Be concise. Respond in the same language as the user's original message.`, timestamp: Date.now() },
                         ];
                         // Get follow-up response
                         let followUp;
@@ -127,11 +141,21 @@ You are running locally on the user's machine. No data leaves their computer. Yo
                             case 'google':
                                 followUp = await this.processWithGemini(followUpHistory);
                                 break;
+                            case 'anthropic':
+                                followUp = await this.processWithClaude(followUpHistory);
+                                break;
+                            case 'openai':
+                                followUp = await this.processWithOpenAI(followUpHistory);
+                                break;
+                            case 'kimi':
+                                followUp = await this.processWithKimi(followUpHistory);
+                                break;
                             default:
-                                followUp = { text: resultsText };
+                                // Fallback: return formatted results directly
+                                followUp = { text: this.formatResultsForUser(toolResults) };
                         }
-                        // Combine responses
-                        response.text = followUp.text;
+                        // Use follow-up response (or fallback to formatted results)
+                        response.text = followUp.text || this.formatResultsForUser(toolResults);
                     }
                 }
             }
@@ -149,6 +173,65 @@ You are running locally on the user's machine. No data leaves their computer. Yo
             return { text: `Error: ${errorMsg}` };
         }
     }
+    /**
+     * Format tool results for direct user display (fallback when AI can't summarize)
+     */
+    formatResultsForUser(toolResults) {
+        const parts = [];
+        for (const { call, result } of toolResults) {
+            if (result.success) {
+                const data = result.data;
+                // Format based on tool type
+                if (call.name === 'weather' && data) {
+                    parts.push(`Weather in ${data.location}: ${data.current?.temperature}°C, ${data.current?.condition}`);
+                }
+                else if (call.name === 'datetime' && data) {
+                    parts.push(`Current time: ${data.formatted || data.time}`);
+                }
+                else if (call.name === 'math' && data) {
+                    parts.push(`Result: ${data.result}`);
+                }
+                else if (call.name === 'system_info' && data) {
+                    if (data.memory) {
+                        parts.push(`RAM: ${data.memory.used} / ${data.memory.total} (${data.memory.usage} used)`);
+                    }
+                    if (data.cpu) {
+                        parts.push(`CPU: ${data.cpu.model} (${data.cpu.cores} cores)`);
+                    }
+                }
+                else if (call.name.startsWith('reminder') && data) {
+                    parts.push(data.message || `Reminder ${data.action || 'set'}`);
+                }
+                else if (call.name.startsWith('spotify') && data) {
+                    if (data.track)
+                        parts.push(`Now playing: ${data.track} by ${data.artist}`);
+                    else if (data.message)
+                        parts.push(data.message);
+                    else if (data.action)
+                        parts.push(`Spotify: ${data.action}`);
+                }
+                else if (data) {
+                    // Generic formatting
+                    if (typeof data === 'string') {
+                        parts.push(data);
+                    }
+                    else if (data.message) {
+                        parts.push(data.message);
+                    }
+                    else if (data.result) {
+                        parts.push(String(data.result));
+                    }
+                    else if (data.output) {
+                        parts.push(data.output);
+                    }
+                }
+            }
+            else {
+                parts.push(`Error (${call.name}): ${result.error}`);
+            }
+        }
+        return parts.join('\n') || 'Done.';
+    }
     async processWithKimi(history) {
         // Generic Kimi 2.5 integration wrapper. This implementation is intentionally
         // generic: it will POST to a user-provided `apiUrl` (in config or env) and

package/dist/agent/toolExecutor.js

@@ -114,20 +114,49 @@ function getToolsSystemPrompt() {
     }
     const toolDescriptions = tools.map(t => {
         const params = t.parameters.map(p => `  - ${p.name} (${p.type}${p.required ? ', required' : ''}): ${p.description}`).join('\n');
-        return `**${t.name}**: ${t.description}\nParameters:\n${params}`;
-    }).join('\n\n');
+        return `- **${t.name}**: ${t.description}`;
+    }).join('\n');
     return `
-You have access to the following tools. To use a tool, include a JSON block in your response:
+## TOOLS - IMPORTANT!
+
+You have tools to interact with the real world. **USE THEM AUTOMATICALLY** when the user asks for something that requires them.
+
+**HOW TO USE A TOOL:**
+Include this EXACT format in your response (the system will execute it automatically):
 
 \`\`\`json
-{"tool": "tool_name", "args": {"param1": "value1"}}
+{"tool": "tool_name", "args": {"param": "value"}}
 \`\`\`
 
-Available tools:
+**WHEN TO USE TOOLS (do it automatically, don't ask!):**
+- "what's the weather" → use \`weather\` tool
+- "set a reminder" → use \`reminder_set\` tool  
+- "what time is it" → use \`datetime\` tool
+- "how much RAM" / system info → use \`system_info\` tool
+- "calculate X" / math → use \`math\` tool
+- "read file X" → use \`read_file\` tool
+- "run command X" → use \`shell\` tool
+- "search for X" → use \`web_search\` tool
+- "play music" / spotify → use \`spotify_*\` tools
+- "create playlist" → use \`spotify_create_playlist\` tool
+- "my notes" / obsidian → use \`obsidian_*\` tools
 
+**AVAILABLE TOOLS:**
 ${toolDescriptions}
 
-After I execute the tool, I'll show you the result so you can incorporate it into your response.
+**RULES:**
+1. ALWAYS use a tool when the user's request matches a tool's capability
+2. Do NOT explain how to use tools - just USE them
+3. Do NOT show code examples - execute the tool directly
+4. After tool execution, summarize the result in natural language
+5. If a tool fails, explain why and suggest alternatives
+
+**EXAMPLE:**
+User: "What's the weather in Tokyo?"
+Your response should include:
+\`\`\`json
+{"tool": "weather", "args": {"location": "Tokyo"}}
+\`\`\`
 `;
 }
 /**

package/dist/cli/index.js

@@ -864,12 +864,15 @@ program
                 }
             }
             catch (e) {
-                console.log(chalk.yellow('Gateway not running. Available skills:'));
+                console.log(chalk.yellow('Gateway not running or error connecting.'));
+                console.log(chalk.gray(`(${e.message || 'Connection refused'})\n`));
+                console.log('Available skills:');
                 console.log('');
                 console.log('  - obsidian   Obsidian note-taking integration');
                 console.log('  - weather    Weather forecasts');
                 console.log('  - reminder   Reminders and timers');
                 console.log('  - system     System info and process management');
+                console.log('  - spotify    Spotify music playback control');
                 console.log('');
             }
             break;
@@ -925,13 +928,16 @@ program
         }
     }
     catch (e) {
-        console.log(chalk.yellow('Gateway not running. Built-in tools:'));
+        console.log(chalk.yellow('Gateway not running or error connecting.'));
+        console.log(chalk.gray(`(${e.message || 'Connection refused'})\n`));
+        console.log('Built-in tools:');
         console.log('');
         console.log('  CORE');
         console.log('    shell         Execute shell commands');
         console.log('    read_file     Read file contents');
         console.log('    write_file    Write to files');
         console.log('    list_dir      List directory contents');
+        console.log('    delete_file   Delete files/directories');
         console.log('    edit_file     Edit files (search/replace)');
         console.log('    fetch_url     Fetch web pages');
         console.log('    web_search    Search the web');
@@ -939,6 +945,13 @@ program
         console.log('    math          Mathematical calculations');
         console.log('    convert       Unit conversions');
         console.log('');
+        console.log('  SKILLS (when enabled)');
+        console.log('    obsidian_*    Obsidian notes');
+        console.log('    weather       Weather forecasts');
+        console.log('    reminder_*    Reminders & timers');
+        console.log('    system_*      System info');
+        console.log('    spotify_*     Spotify control');
+        console.log('');
     }
 });
 // ─────────────────────────────────────────────────────────────────

package/dist/skills/spotify.js

@@ -0,0 +1,611 @@
+"use strict";
+/**
+ * Spotify Skill
+ *
+ * Integration with Spotify for music playback control.
+ * Uses Spotify Web API - requires user authentication via OAuth.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+// Spotify API state
+let accessToken = '';
+let refreshToken = '';
+let clientId = '';
+let clientSecret = '';
+let tokenExpiry = 0;
+const SPOTIFY_API = 'https://api.spotify.com/v1';
+const SPOTIFY_ACCOUNTS = 'https://accounts.spotify.com';
+async function refreshAccessToken() {
+    if (!refreshToken || !clientId || !clientSecret) {
+        return false;
+    }
+    try {
+        const res = await fetch(`${SPOTIFY_ACCOUNTS}/api/token`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/x-www-form-urlencoded',
+                'Authorization': 'Basic ' + Buffer.from(`${clientId}:${clientSecret}`).toString('base64'),
+            },
+            body: `grant_type=refresh_token&refresh_token=${refreshToken}`,
+        });
+        if (!res.ok)
+            return false;
+        const data = await res.json();
+        accessToken = data.access_token;
+        tokenExpiry = Date.now() + (data.expires_in * 1000);
+        if (data.refresh_token) {
+            refreshToken = data.refresh_token;
+        }
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function spotifyFetch(endpoint, options = {}) {
+    // Check if token needs refresh
+    if (Date.now() >= tokenExpiry - 60000) {
+        await refreshAccessToken();
+    }
+    if (!accessToken) {
+        throw new Error('Spotify not authenticated. Please configure your Spotify credentials.');
+    }
+    const res = await fetch(`${SPOTIFY_API}${endpoint}`, {
+        ...options,
+        headers: {
+            'Authorization': `Bearer ${accessToken}`,
+            'Content-Type': 'application/json',
+            ...options.headers,
+        },
+    });
+    if (res.status === 401) {
+        // Try refresh
+        if (await refreshAccessToken()) {
+            return spotifyFetch(endpoint, options);
+        }
+        throw new Error('Spotify authentication expired. Please re-authenticate.');
+    }
+    if (!res.ok) {
+        const error = await res.json().catch(() => ({}));
+        throw new Error(error.error?.message || `Spotify API error: ${res.status}`);
+    }
+    // Handle empty responses
+    if (res.status === 204) {
+        return { success: true };
+    }
+    return res.json();
+}
+// ─────────────────────────────────────────────────────────────────
+// Spotify Tools
+// ─────────────────────────────────────────────────────────────────
+const spotifyNowPlayingTool = {
+    definition: {
+        name: 'spotify_now_playing',
+        description: 'Get the currently playing track on Spotify.',
+        category: 'media',
+        parameters: [],
+        returns: 'Current track info',
+    },
+    async execute(params, context) {
+        try {
+            const data = await spotifyFetch('/me/player/currently-playing');
+            if (!data || !data.item) {
+                return {
+                    success: true,
+                    data: { playing: false, message: 'Nothing is currently playing' },
+                };
+            }
+            return {
+                success: true,
+                data: {
+                    playing: data.is_playing,
+                    track: data.item.name,
+                    artist: data.item.artists.map((a) => a.name).join(', '),
+                    album: data.item.album.name,
+                    duration: Math.floor(data.item.duration_ms / 1000),
+                    progress: Math.floor(data.progress_ms / 1000),
+                    url: data.item.external_urls.spotify,
+                },
+            };
+        }
+        catch (error) {
+            return { success: false, error: error.message };
+        }
+    },
+};
+const spotifyPlayTool = {
+    definition: {
+        name: 'spotify_play',
+        description: 'Play music on Spotify. Can play a specific track, album, playlist, or resume playback.',
+        category: 'media',
+        parameters: [
+            {
+                name: 'query',
+                type: 'string',
+                description: 'Search query for track, album, or playlist (optional - omit to resume)',
+                required: false,
+            },
+            {
+                name: 'type',
+                type: 'string',
+                description: 'Type to search: track, album, playlist, artist',
+                required: false,
+                default: 'track',
+                enum: ['track', 'album', 'playlist', 'artist'],
+            },
+        ],
+        returns: 'Playback status',
+        examples: [
+            'spotify_play() - Resume playback',
+            'spotify_play({ query: "Bohemian Rhapsody" })',
+            'spotify_play({ query: "Chill Vibes", type: "playlist" })',
+        ],
+    },
+    async execute(params, context) {
+        try {
+            const { query, type = 'track' } = params;
+            if (!query) {
+                // Resume playback
+                await spotifyFetch('/me/player/play', { method: 'PUT' });
+                return {
+                    success: true,
+                    data: { action: 'resumed', message: 'Playback resumed' },
+                };
+            }
+            // Search for content
+            const searchResult = await spotifyFetch(`/search?q=${encodeURIComponent(query)}&type=${type}&limit=1`);
+            const items = searchResult[`${type}s`]?.items;
+            if (!items || items.length === 0) {
+                return { success: false, error: `No ${type} found for: ${query}` };
+            }
+            const item = items[0];
+            let body = {};
+            if (type === 'track') {
+                body = { uris: [item.uri] };
+            }
+            else {
+                body = { context_uri: item.uri };
+            }
+            await spotifyFetch('/me/player/play', {
+                method: 'PUT',
+                body: JSON.stringify(body),
+            });
+            return {
+                success: true,
+                data: {
+                    action: 'playing',
+                    type,
+                    name: item.name,
+                    artist: item.artists?.[0]?.name || item.owner?.display_name,
+                    url: item.external_urls.spotify,
+                },
+            };
+        }
+        catch (error) {
+            return { success: false, error: error.message };
+        }
+    },
+};
+const spotifyPauseTool = {
+    definition: {
+        name: 'spotify_pause',
+        description: 'Pause Spotify playback.',
+        category: 'media',
+        parameters: [],
+        returns: 'Pause confirmation',
+    },
+    async execute(params, context) {
+        try {
+            await spotifyFetch('/me/player/pause', { method: 'PUT' });
+            return {
+                success: true,
+                data: { action: 'paused', message: 'Playback paused' },
+            };
+        }
+        catch (error) {
+            return { success: false, error: error.message };
+        }
+    },
+};
+const spotifyNextTool = {
+    definition: {
+        name: 'spotify_next',
+        description: 'Skip to the next track.',
+        category: 'media',
+        parameters: [],
+        returns: 'Skip confirmation',
+    },
+    async execute(params, context) {
+        try {
+            await spotifyFetch('/me/player/next', { method: 'POST' });
+            return {
+                success: true,
+                data: { action: 'skipped', message: 'Skipped to next track' },
+            };
+        }
+        catch (error) {
+            return { success: false, error: error.message };
+        }
+    },
+};
+const spotifyPreviousTool = {
+    definition: {
+        name: 'spotify_previous',
+        description: 'Go back to the previous track.',
+        category: 'media',
+        parameters: [],
+        returns: 'Previous confirmation',
+    },
+    async execute(params, context) {
+        try {
+            await spotifyFetch('/me/player/previous', { method: 'POST' });
+            return {
+                success: true,
+                data: { action: 'previous', message: 'Playing previous track' },
+            };
+        }
+        catch (error) {
+            return { success: false, error: error.message };
+        }
+    },
+};
+const spotifyVolumeTool = {
+    definition: {
+        name: 'spotify_volume',
+        description: 'Set Spotify playback volume.',
+        category: 'media',
+        parameters: [
+            {
+                name: 'volume',
+                type: 'number',
+                description: 'Volume level (0-100)',
+                required: true,
+            },
+        ],
+        returns: 'Volume confirmation',
+    },
+    async execute(params, context) {
+        try {
+            const { volume } = params;
+            const level = Math.max(0, Math.min(100, volume));
+            await spotifyFetch(`/me/player/volume?volume_percent=${level}`, { method: 'PUT' });
+            return {
+                success: true,
+                data: { action: 'volume', level, message: `Volume set to ${level}%` },
+            };
+        }
+        catch (error) {
+            return { success: false, error: error.message };
+        }
+    },
+};
+const spotifySearchTool = {
+    definition: {
+        name: 'spotify_search',
+        description: 'Search Spotify for tracks, albums, artists, or playlists.',
+        category: 'media',
+        parameters: [
+            {
+                name: 'query',
+                type: 'string',
+                description: 'Search query',
+                required: true,
+            },
+            {
+                name: 'type',
+                type: 'string',
+                description: 'Type to search: track, album, artist, playlist',
+                required: false,
+                default: 'track',
+                enum: ['track', 'album', 'artist', 'playlist'],
+            },
+            {
+                name: 'limit',
+                type: 'number',
+                description: 'Number of results (default: 5)',
+                required: false,
+                default: 5,
+            },
+        ],
+        returns: 'Search results',
+    },
+    async execute(params, context) {
+        try {
+            const { query, type = 'track', limit = 5 } = params;
+            const data = await spotifyFetch(`/search?q=${encodeURIComponent(query)}&type=${type}&limit=${limit}`);
+            const items = data[`${type}s`]?.items || [];
+            const results = items.map((item) => ({
+                name: item.name,
+                artist: item.artists?.[0]?.name || item.owner?.display_name,
+                album: item.album?.name,
+                url: item.external_urls.spotify,
+                uri: item.uri,
+            }));
+            return {
+                success: true,
+                data: {
+                    query,
+                    type,
+                    results,
+                    count: results.length,
+                },
+            };
+        }
+        catch (error) {
+            return { success: false, error: error.message };
+        }
+    },
+};
+const spotifyPlaylistsTool = {
+    definition: {
+        name: 'spotify_playlists',
+        description: 'Get your Spotify playlists.',
+        category: 'media',
+        parameters: [
+            {
+                name: 'limit',
+                type: 'number',
+                description: 'Number of playlists (default: 20)',
+                required: false,
+                default: 20,
+            },
+        ],
+        returns: 'List of playlists',
+    },
+    async execute(params, context) {
+        try {
+            const { limit = 20 } = params;
+            const data = await spotifyFetch(`/me/playlists?limit=${limit}`);
+            const playlists = data.items.map((p) => ({
+                name: p.name,
+                tracks: p.tracks.total,
+                owner: p.owner.display_name,
+                public: p.public,
+                url: p.external_urls.spotify,
+                uri: p.uri,
+            }));
+            return {
+                success: true,
+                data: {
+                    playlists,
+                    count: playlists.length,
+                },
+            };
+        }
+        catch (error) {
+            return { success: false, error: error.message };
+        }
+    },
+};
+const spotifyCreatePlaylistTool = {
+    definition: {
+        name: 'spotify_create_playlist',
+        description: 'Create a new Spotify playlist.',
+        category: 'media',
+        parameters: [
+            {
+                name: 'name',
+                type: 'string',
+                description: 'Playlist name',
+                required: true,
+            },
+            {
+                name: 'description',
+                type: 'string',
+                description: 'Playlist description',
+                required: false,
+            },
+            {
+                name: 'public',
+                type: 'boolean',
+                description: 'Make playlist public',
+                required: false,
+                default: false,
+            },
+        ],
+        returns: 'Created playlist info',
+    },
+    async execute(params, context) {
+        try {
+            const { name, description, public: isPublic = false } = params;
+            // Get user ID first
+            const user = await spotifyFetch('/me');
+            const playlist = await spotifyFetch(`/users/${user.id}/playlists`, {
+                method: 'POST',
+                body: JSON.stringify({
+                    name,
+                    description: description || '',
+                    public: isPublic,
+                }),
+            });
+            return {
+                success: true,
+                data: {
+                    action: 'created',
+                    name: playlist.name,
+                    id: playlist.id,
+                    url: playlist.external_urls.spotify,
+                    uri: playlist.uri,
+                },
+            };
+        }
+        catch (error) {
+            return { success: false, error: error.message };
+        }
+    },
+};
+const spotifyAddToPlaylistTool = {
+    definition: {
+        name: 'spotify_add_to_playlist',
+        description: 'Add tracks to a playlist.',
+        category: 'media',
+        parameters: [
+            {
+                name: 'playlist',
+                type: 'string',
+                description: 'Playlist name or ID',
+                required: true,
+            },
+            {
+                name: 'tracks',
+                type: 'string',
+                description: 'Track name to search and add, or track URI',
+                required: true,
+            },
+        ],
+        returns: 'Add confirmation',
+    },
+    async execute(params, context) {
+        try {
+            const { playlist, tracks } = params;
+            // Find playlist
+            let playlistId = playlist;
+            if (!playlist.startsWith('spotify:playlist:')) {
+                const playlists = await spotifyFetch('/me/playlists?limit=50');
+                const found = playlists.items.find((p) => p.name.toLowerCase() === playlist.toLowerCase() || p.id === playlist);
+                if (!found) {
+                    return { success: false, error: `Playlist not found: ${playlist}` };
+                }
+                playlistId = found.id;
+            }
+            else {
+                playlistId = playlist.replace('spotify:playlist:', '');
+            }
+            // Find track if not URI
+            let trackUri = tracks;
+            if (!tracks.startsWith('spotify:track:')) {
+                const search = await spotifyFetch(`/search?q=${encodeURIComponent(tracks)}&type=track&limit=1`);
+                const track = search.tracks?.items?.[0];
+                if (!track) {
+                    return { success: false, error: `Track not found: ${tracks}` };
+                }
+                trackUri = track.uri;
+            }
+            await spotifyFetch(`/playlists/${playlistId}/tracks`, {
+                method: 'POST',
+                body: JSON.stringify({ uris: [trackUri] }),
+            });
+            return {
+                success: true,
+                data: {
+                    action: 'added',
+                    playlist: playlistId,
+                    track: trackUri,
+                    message: 'Track added to playlist',
+                },
+            };
+        }
+        catch (error) {
+            return { success: false, error: error.message };
+        }
+    },
+};
+const spotifyDevicesTool = {
+    definition: {
+        name: 'spotify_devices',
+        description: 'List available Spotify playback devices.',
+        category: 'media',
+        parameters: [],
+        returns: 'List of devices',
+    },
+    async execute(params, context) {
+        try {
+            const data = await spotifyFetch('/me/player/devices');
+            const devices = data.devices.map((d) => ({
+                name: d.name,
+                type: d.type,
+                active: d.is_active,
+                volume: d.volume_percent,
+                id: d.id,
+            }));
+            return {
+                success: true,
+                data: {
+                    devices,
+                    count: devices.length,
+                },
+            };
+        }
+        catch (error) {
+            return { success: false, error: error.message };
+        }
+    },
+};
+// ─────────────────────────────────────────────────────────────────
+// Skill Definition
+// ─────────────────────────────────────────────────────────────────
+const manifest = {
+    name: 'spotify',
+    version: '1.0.0',
+    description: 'Spotify music playback control and playlist management',
+    category: 'media',
+    icon: 'music',
+    homepage: 'https://developer.spotify.com/documentation/web-api',
+    tools: [
+        'spotify_now_playing',
+        'spotify_play',
+        'spotify_pause',
+        'spotify_next',
+        'spotify_previous',
+        'spotify_volume',
+        'spotify_search',
+        'spotify_playlists',
+        'spotify_create_playlist',
+        'spotify_add_to_playlist',
+        'spotify_devices',
+    ],
+    config: [
+        {
+            name: 'clientId',
+            type: 'string',
+            description: 'Spotify App Client ID (from developer.spotify.com)',
+            required: true,
+        },
+        {
+            name: 'clientSecret',
+            type: 'secret',
+            description: 'Spotify App Client Secret',
+            required: true,
+        },
+        {
+            name: 'refreshToken',
+            type: 'secret',
+            description: 'Spotify OAuth Refresh Token',
+            required: true,
+        },
+    ],
+    permissions: ['user-read-playback-state', 'user-modify-playback-state', 'playlist-read-private', 'playlist-modify-public', 'playlist-modify-private'],
+};
+const spotifySkill = {
+    manifest,
+    tools: [
+        spotifyNowPlayingTool,
+        spotifyPlayTool,
+        spotifyPauseTool,
+        spotifyNextTool,
+        spotifyPreviousTool,
+        spotifyVolumeTool,
+        spotifySearchTool,
+        spotifyPlaylistsTool,
+        spotifyCreatePlaylistTool,
+        spotifyAddToPlaylistTool,
+        spotifyDevicesTool,
+    ],
+    async initialize(config) {
+        clientId = config.clientId || process.env.SPOTIFY_CLIENT_ID || '';
+        clientSecret = config.clientSecret || process.env.SPOTIFY_CLIENT_SECRET || '';
+        refreshToken = config.refreshToken || process.env.SPOTIFY_REFRESH_TOKEN || '';
+        if (clientId && clientSecret && refreshToken) {
+            await refreshAccessToken();
+            console.log('[Spotify] Initialized and authenticated');
+        }
+        else {
+            console.log('[Spotify] Initialized (credentials not configured)');
+        }
+    },
+    async shutdown() {
+        accessToken = '';
+        refreshToken = '';
+        console.log('[Spotify] Shutdown');
+    },
+};
+exports.default = spotifySkill;

package/dist/tools/loader.js

@@ -24,6 +24,7 @@ const obsidian_1 = __importDefault(require("../skills/obsidian"));
 const weather_1 = __importDefault(require("../skills/weather"));
 const reminder_1 = __importDefault(require("../skills/reminder"));
 const system_1 = __importDefault(require("../skills/system"));
+const spotify_1 = __importDefault(require("../skills/spotify"));
 /**
  * Register all built-in tools
  */
@@ -49,6 +50,7 @@ async function registerSkills(configDir) {
     skillManager.register(weather_1.default);
     skillManager.register(reminder_1.default);
     skillManager.register(system_1.default);
+    skillManager.register(spotify_1.default);
     // Initialize enabled skills
     await skillManager.initializeEnabled();
     console.log(`[Loader] Registered ${skillManager.list().length} skills`);

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "apexbot",
-  "version": "1.0.4",
-  "description": "ApexBot - Your free, private AI assistant. 100% free with Ollama (local AI). Multi-channel: Telegram, Discord, WebChat. Tools & Skills system like Clawdbot!",
+  "version": "1.0.6",
+  "description": "ApexBot - Your free, private AI assistant. 100% free with Ollama (local AI). Multi-channel: Telegram, Discord, WebChat. Tools & Skills system with Spotify, Obsidian, and more!",
   "main": "dist/index.js",
   "bin": {
     "apexbot": "./dist/cli/index.js"