skimpyclaw 0.1.7 → 0.1.9

package/README.md

@@ -95,6 +95,23 @@ Onboarding validates your Telegram token, provider auth, and creates:
 
 ```bash
 skimpyclaw start
+# or run as launchd daemon on macOS:
+skimpyclaw start --daemon
+```
+
+**Stop/Restart daemon (macOS):**
+
+```bash
+skimpyclaw stop
+skimpyclaw restart
+```
+
+**Uninstall helper:**
+
+```bash
+skimpyclaw uninstall          # removes launch agent, keeps ~/.skimpyclaw
+skimpyclaw uninstall --purge  # removes launch agent and ~/.skimpyclaw
+pnpm remove -g skimpyclaw     # removes global package
 ```
 
 **Verify:**

package/dist/__tests__/cli.test.js

@@ -1,11 +1,18 @@
 import { beforeEach, describe, expect, it, vi } from 'vitest';
 const CONFIG_PATH = '/tmp/skimpyclaw-test-config.json';
-const { mockLoadConfig, mockLoadRawConfig, mockSaveConfig, mockRunSetup, mockRunDoctor, } = vi.hoisted(() => ({
+const { mockLoadConfig, mockLoadRawConfig, mockSaveConfig, mockRunSetup, mockRunDoctor, mockExistsSync, mockMkdirSync, mockReadFileSync, mockWriteFileSync, mockRmSync, mockSpawn, mockSpawnSync, } = vi.hoisted(() => ({
     mockLoadConfig: vi.fn(),
     mockLoadRawConfig: vi.fn(),
     mockSaveConfig: vi.fn(),
     mockRunSetup: vi.fn(),
     mockRunDoctor: vi.fn(),
+    mockExistsSync: vi.fn(),
+    mockMkdirSync: vi.fn(),
+    mockReadFileSync: vi.fn(),
+    mockWriteFileSync: vi.fn(),
+    mockRmSync: vi.fn(),
+    mockSpawn: vi.fn(),
+    mockSpawnSync: vi.fn(),
 }));
 vi.mock('../config.js', () => ({
     loadConfig: mockLoadConfig,
@@ -22,6 +29,20 @@ vi.mock('../service.js', () => ({
 vi.mock('../doctor/index.js', () => ({
     runDoctor: mockRunDoctor,
 }));
+vi.mock('os', () => ({
+    homedir: () => '/tmp/skimpyclaw-test-home',
+}));
+vi.mock('fs', () => ({
+    existsSync: mockExistsSync,
+    mkdirSync: mockMkdirSync,
+    readFileSync: mockReadFileSync,
+    writeFileSync: mockWriteFileSync,
+    rmSync: mockRmSync,
+}));
+vi.mock('child_process', () => ({
+    spawn: mockSpawn,
+    spawnSync: mockSpawnSync,
+}));
 import { parseConfigValue, setDeepValue, getDeepValue, runCli } from '../cli.js';
 function mockJsonResponse(body, ok = true) {
     return {
@@ -69,6 +90,13 @@ describe('runCli', () => {
         mockSaveConfig.mockReset();
         mockRunSetup.mockReset();
         mockRunDoctor.mockReset();
+        mockExistsSync.mockReset();
+        mockMkdirSync.mockReset();
+        mockReadFileSync.mockReset();
+        mockWriteFileSync.mockReset();
+        mockRmSync.mockReset();
+        mockSpawn.mockReset();
+        mockSpawnSync.mockReset();
         mockLoadConfig.mockReturnValue({
             gateway: { port: 18790 },
             models: { aliases: { fast: 'anthropic/claude-3-5-haiku-20241022' } },
@@ -77,6 +105,9 @@ describe('runCli', () => {
             gateway: { port: 18790 },
             channels: { telegram: { enabled: false } },
         });
+        mockExistsSync.mockReturnValue(false);
+        mockSpawnSync.mockReturnValue({ status: 1, stdout: '', stderr: '' });
+        mockReadFileSync.mockReturnValue('{}');
         vi.spyOn(console, 'log').mockImplementation(() => { });
         vi.spyOn(console, 'error').mockImplementation(() => { });
         vi.stubGlobal('fetch', vi.fn());
@@ -98,6 +129,30 @@ describe('runCli', () => {
         expect(mockRunSetup).toHaveBeenCalledTimes(1);
         expect(mockRunSetup).toHaveBeenCalledWith({ dryRun: true });
     });
+    it('uninstall removes launch agent and keeps data by default', async () => {
+        mockExistsSync.mockImplementation((path) => typeof path === 'string'
+            && path.includes('/Library/LaunchAgents/com.skimpyclaw.gateway.plist'));
+        const code = await runCli(['uninstall']);
+        expect(code).toBe(0);
+        expect(mockRmSync).toHaveBeenCalledWith('/tmp/skimpyclaw-test-home/Library/LaunchAgents/com.skimpyclaw.gateway.plist', { force: true });
+        expect(mockRmSync).not.toHaveBeenCalledWith('/tmp/skimpyclaw-test-home/.skimpyclaw', expect.anything());
+        expect(console.log).toHaveBeenCalledWith(expect.stringContaining('Kept data directory'));
+    });
+    it('uninstall purges data when --purge is provided', async () => {
+        mockExistsSync.mockReturnValue(true);
+        const code = await runCli(['uninstall', '--purge']);
+        expect(code).toBe(0);
+        expect(mockRmSync).toHaveBeenCalledWith('/tmp/skimpyclaw-test-home/.skimpyclaw', {
+            recursive: true,
+            force: true,
+        });
+        expect(console.log).toHaveBeenCalledWith(expect.stringContaining('Purged data directory'));
+    });
+    it('uninstall rejects conflicting flags', async () => {
+        const code = await runCli(['uninstall', '--purge', '--keep-data']);
+        expect(code).toBe(1);
+        expect(console.error).toHaveBeenCalledWith('Usage: skimpyclaw uninstall [--keep-data|--purge]');
+    });
     it('supports config path/get/set operations', async () => {
         const pathCode = await runCli(['config', 'path']);
         expect(pathCode).toBe(0);

package/dist/__tests__/heartbeat.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/__tests__/heartbeat.test.js

@@ -0,0 +1,71 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+const { mockRunAgentTurn } = vi.hoisted(() => ({
+    mockRunAgentTurn: vi.fn(),
+}));
+vi.mock('../agent.js', () => ({
+    runAgentTurn: mockRunAgentTurn,
+}));
+vi.mock('../channels.js', () => ({
+    getActiveChannelId: () => 'telegram',
+    isActiveChannelSilenced: () => false,
+    sendActiveChannelProactiveMessage: vi.fn(async () => true),
+}));
+import { runHeartbeatCheck } from '../heartbeat.js';
+describe('heartbeat prompt path normalization', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+        mockRunAgentTurn.mockResolvedValue('HEARTBEAT_OK');
+    });
+    it('normalizes legacy heartbeat file path to agents/main/HEARTBEAT.md', async () => {
+        const config = {
+            agents: { default: 'main' },
+            heartbeat: {
+                intervalMs: 60000,
+                prompt: 'Read /Users/katre/HEARTBEAT.md only. Reply HEARTBEAT_OK.',
+                model: 'claude-fast',
+                tools: {
+                    enabled: true,
+                    allowedPaths: ['/Users/katre/.skimpyclaw'],
+                    maxIterations: 10,
+                    bashTimeout: 15000,
+                },
+            },
+            channels: {
+                active: 'telegram',
+                telegram: {
+                    defaultAllowedPaths: ['/Users/katre/.skimpyclaw'],
+                },
+            },
+        };
+        await runHeartbeatCheck(config);
+        expect(mockRunAgentTurn).toHaveBeenCalledTimes(1);
+        expect(mockRunAgentTurn).toHaveBeenCalledWith('main', expect.stringContaining('/.skimpyclaw/agents/main/HEARTBEAT.md'), config, 'claude-fast', expect.any(Object), undefined, expect.any(Object));
+    });
+    it('normalizes /workspace heartbeat path to agents/main/HEARTBEAT.md', async () => {
+        const config = {
+            agents: { default: 'main' },
+            heartbeat: {
+                intervalMs: 60000,
+                prompt: 'Read /workspace/HEARTBEAT.md only. Reply HEARTBEAT_OK.',
+                model: 'claude-fast',
+                tools: {
+                    enabled: true,
+                    allowedPaths: ['/Users/katre/.skimpyclaw'],
+                    maxIterations: 10,
+                    bashTimeout: 15000,
+                },
+            },
+            channels: {
+                active: 'telegram',
+                telegram: {
+                    defaultAllowedPaths: ['/Users/katre/.skimpyclaw'],
+                },
+            },
+        };
+        await runHeartbeatCheck(config);
+        expect(mockRunAgentTurn).toHaveBeenCalledTimes(1);
+        const promptArg = mockRunAgentTurn.mock.calls[0][1];
+        expect(promptArg).toContain('/.skimpyclaw/agents/main/HEARTBEAT.md');
+        expect(promptArg).not.toContain('/workspace/HEARTBEAT.md');
+    });
+});

package/dist/__tests__/setup.test.js

@@ -15,7 +15,10 @@ describe('setup config generation', () => {
         expect(config.models.providers.anthropic.apiKey).toBe('${ANTHROPIC_API_KEY}');
         expect(config.models.providers.codex.authPath).toBe('${HOME}/.codex/auth.json');
         expect(config.channels.telegram.allowFrom).toEqual([12345]);
-        expect(config.channels.telegram.defaultAllowedPaths).toContain('/tmp/workspace');
+        expect(config.channels.telegram.dailyNotesDir).toBe('${HOME}/.skimpyclaw/Daily Notes');
+        expect(config.channels.telegram.defaultAllowedPaths).toEqual(['${HOME}/.skimpyclaw']);
+        expect(config.channels.discord.defaultAllowedPaths).toEqual(['${HOME}/.skimpyclaw']);
+        expect(config.heartbeat.tools.allowedPaths).toEqual(['${HOME}/.skimpyclaw']);
         expect(config.models.aliases['claude-think']).toBe('anthropic/claude-sonnet-4-6');
         expect(config.models.aliases['claude-opus']).toBe('anthropic/claude-opus-4-6');
         expect(config.models.aliases.codex).toBe('codex/gpt-5.3-codex');

package/dist/__tests__/voice.test.js

@@ -34,7 +34,7 @@ vi.mock('fs', async (importOriginal) => {
 const mockFetch = vi.fn();
 global.fetch = mockFetch;
 // Import after mocks are set up
-const { synthesizeSpeech, checkTTSDependencies } = await import('../voice.js');
+const { synthesizeSpeech, checkTTSDependencies, checkVoiceDependencies } = await import('../voice.js');
 // --- Config helpers ---
 const baseVoiceConfig = {
     enabled: true,
@@ -212,3 +212,43 @@ describe('checkTTSDependencies', () => {
         }
     });
 });
+describe('checkVoiceDependencies', () => {
+    it('ignores macos provider for STT and uses API-backed provider', () => {
+        const config = {
+            ...baseVoiceConfig,
+            defaultProvider: 'macos',
+            providers: {
+                macos: { tts: { voice: 'Samantha' } },
+                openai: { apiKey: 'openai-key', stt: { model: 'whisper-1' } },
+            },
+        };
+        const result = checkVoiceDependencies(config);
+        expect(result.ok).toBe(true);
+        expect(result.localWhisper).toBe(false);
+        expect(result.missing).toHaveLength(0);
+    });
+    it('reports missing STT provider when only macos provider is configured', () => {
+        const config = {
+            ...baseVoiceConfig,
+            defaultProvider: 'macos',
+            providers: {
+                macos: { tts: { voice: 'Samantha' } },
+            },
+        };
+        const result = checkVoiceDependencies(config);
+        expect(result.ok).toBe(false);
+        expect(result.missing[0]).toContain('No local whisper CLI and no API providers configured');
+    });
+});
+describe('transcription provider messaging', () => {
+    it('explains that macos is TTS-only when no STT provider exists', async () => {
+        const { transcribeAudio } = await import('../voice.js');
+        const config = {
+            ...baseVoiceConfig,
+            providers: {
+                macos: { tts: { voice: 'Samantha' } },
+            },
+        };
+        await expect(transcribeAudio('/tmp/fake-audio.ogg', config)).rejects.toThrow('macos" is TTS-only');
+    });
+});

package/dist/cli.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs';
+import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from 'fs';
 import { join } from 'path';
 import { homedir } from 'os';
 import { spawn, spawnSync } from 'child_process';
@@ -21,6 +21,8 @@ Commands:
   start [--daemon]        Start service (foreground by default)
   stop                    Stop launchd daemon (macOS)
   restart                 Restart launchd daemon (macOS)
+  uninstall [--keep-data|--purge]
+                          Remove launch agent and optionally purge ~/.skimpyclaw
   status                  Show daemon and gateway status
   logs [--file name]      Show logs (stdout|stderr|app), default stdout
        [--lines N]
@@ -153,6 +155,38 @@ function stopDaemon() {
     console.log(`Daemon stopped: ${LAUNCHD_LABEL}`);
     return 0;
 }
+function commandUninstall(args) {
+    const hasPurge = args.includes('--purge');
+    const hasKeepData = args.includes('--keep-data');
+    const unknownFlags = args.filter((arg) => arg.startsWith('--') && arg !== '--purge' && arg !== '--keep-data');
+    if (unknownFlags.length > 0 || (hasPurge && hasKeepData)) {
+        console.error('Usage: skimpyclaw uninstall [--keep-data|--purge]');
+        return 1;
+    }
+    if (existsSync(LAUNCHD_PLIST) && launchctlAvailable()) {
+        const stopResult = runLaunchctl(['unload', LAUNCHD_PLIST]);
+        if (!stopResult.ok && !stopResult.output.includes('Could not find specified service')) {
+            console.error(`Warning: failed to unload daemon: ${stopResult.output || 'unknown error'}`);
+        }
+    }
+    if (existsSync(LAUNCHD_PLIST)) {
+        rmSync(LAUNCHD_PLIST, { force: true });
+        console.log(`Removed launch agent: ${LAUNCHD_PLIST}`);
+    }
+    else {
+        console.log('No launch agent found.');
+    }
+    const dataDir = join(homedir(), '.skimpyclaw');
+    if (hasPurge) {
+        rmSync(dataDir, { recursive: true, force: true });
+        console.log(`Purged data directory: ${dataDir}`);
+    }
+    else {
+        console.log(`Kept data directory: ${dataDir}`);
+    }
+    console.log('To remove the global package, run: pnpm remove -g skimpyclaw');
+    return 0;
+}
 function daemonStatus() {
     if (!launchctlAvailable()) {
         return 'unsupported';
@@ -713,6 +747,9 @@ export async function runCli(argv = process.argv.slice(2)) {
             }
             return startDaemon();
         }
+        if (command === 'uninstall') {
+            return commandUninstall(args);
+        }
         if (command === 'status') {
             return await commandStatus();
         }

package/dist/heartbeat.js

@@ -11,7 +11,7 @@ let heartbeatTimer = null;
 let running = false;
 const DEFAULT_HEARTBEAT_TOOLS = {
     enabled: true,
-    allowedPaths: [join(homedir(), '.skimpyclaw'), process.cwd()],
+    allowedPaths: [join(homedir(), '.skimpyclaw')],
     maxIterations: 100,
     bashTimeout: 15000,
 };
@@ -30,6 +30,23 @@ function getHeartbeatTools(config) {
     }
     return DEFAULT_HEARTBEAT_TOOLS;
 }
+function getHeartbeatFilePath(config) {
+    return join(homedir(), '.skimpyclaw', 'agents', config.agents.default, 'HEARTBEAT.md');
+}
+function getHeartbeatPrompt(config) {
+    const heartbeatPath = getHeartbeatFilePath(config);
+    const basePrompt = config.heartbeat.prompt || '';
+    // Normalize any explicit HEARTBEAT.md path token (legacy /workspace, /Users/*, ~/...)
+    // to the active agent heartbeat template path.
+    const normalized = basePrompt.replace(/(?:~|\/)\S*HEARTBEAT\.md/g, heartbeatPath);
+    if (normalized.includes('HEARTBEAT.md')) {
+        return normalized;
+    }
+    if (normalized.trim().length === 0) {
+        return `Read ${heartbeatPath}. Follow it strictly. If nothing needs attention, reply HEARTBEAT_OK.`;
+    }
+    return `Read ${heartbeatPath}. Follow it strictly.\n\n${normalized}`;
+}
 export function initHeartbeat(config) {
     const { heartbeat } = config;
     if (!heartbeat?.prompt || !heartbeat?.intervalMs) {
@@ -68,7 +85,7 @@ export async function runHeartbeatCheck(config) {
     running = true;
     try {
         console.log('[heartbeat] Running check...');
-        const response = await runAgentTurn(config.agents.default, config.heartbeat.prompt, config, config.heartbeat.model, getHeartbeatTools(config), undefined, {
+        const response = await runAgentTurn(config.agents.default, getHeartbeatPrompt(config), config, config.heartbeat.model, getHeartbeatTools(config), undefined, {
             channel: 'heartbeat',
             sessionId: undefined,
         });

package/dist/providers/openai.js

@@ -128,16 +128,12 @@ export async function chatWithToolsOpenAI(params, provider) {
         projects: toolContext?.fullConfig?.projects
     });
     const openaiTools = toOpenAITools(toolDefs);
-    // Inject Kimi $web_search builtin tool when using Moonshot/Kimi provider
+    // Kimi requires interleaved reasoning content when replaying tool calls.
     const providerBaseURL = config.models.providers[provider]?.baseURL || '';
     const requiresReasoningContent = providerBaseURL.includes('kimi.com') || providerBaseURL.includes('moonshot.ai');
     const kimiRequestExtras = requiresReasoningContent
         ? { extra_body: { interleaved: { field: 'reasoning_content' } } }
         : {};
-    if (providerBaseURL.includes('kimi.com') || providerBaseURL.includes('moonshot.ai')) {
-        openaiTools.push({ type: 'builtin_function', function: { name: '$web_search' } });
-        console.log('[agent:openai-tools] Injected Kimi $web_search builtin tool');
-    }
     // Build messages for OpenAI format — preserve images for vision models
     const apiMessages = messages.map(m => ({
         role: m.role,
@@ -252,6 +248,17 @@ export async function chatWithToolsOpenAI(params, provider) {
         // Execute each tool call
         for (const toolCall of message.tool_calls) {
             const fnName = toolCall.function.name;
+            if (fnName.startsWith('$') && fnName !== '$web_search') {
+                const unsupported = `Provider-native tool "${fnName}" is not supported in this runtime.`;
+                console.warn(`[agent:openai-tools] ${unsupported}`);
+                apiMessages.push({
+                    role: 'tool',
+                    tool_call_id: toolCall.id,
+                    content: unsupported,
+                });
+                toolLog.push(`${fnName} [SKIPPED: provider-native tool unsupported]`);
+                continue;
+            }
             let args;
             try {
                 args = JSON.parse(toolCall.function.arguments || '{}');

package/dist/setup.js

@@ -376,20 +376,14 @@ export function buildSetupConfig(input) {
                 enabled: true,
                 token: '${TELEGRAM_BOT_TOKEN}',
                 allowFrom: [parseInt(input.telegramId, 10) || input.telegramId],
-                dailyNotesDir: '${HOME}/Daily Notes',
-                defaultAllowedPaths: [
-                    '${HOME}/.skimpyclaw',
-                    input.workspaceDir,
-                ],
+                dailyNotesDir: '${HOME}/.skimpyclaw/Daily Notes',
+                defaultAllowedPaths: ['${HOME}/.skimpyclaw'],
             },
             discord: {
                 enabled: useDiscord,
                 token: useDiscord ? '${DISCORD_BOT_TOKEN}' : '',
                 allowFrom: useDiscord ? [input.discordUserId || ''] : [],
-                defaultAllowedPaths: [
-                    '${HOME}/.skimpyclaw',
-                    input.workspaceDir,
-                ],
+                defaultAllowedPaths: ['${HOME}/.skimpyclaw'],
                 ...(input.discordDefaultChannelId ? { defaultChannelId: input.discordDefaultChannelId } : {}),
             },
         },
@@ -401,10 +395,7 @@ export function buildSetupConfig(input) {
             prompt: 'Read ~/.skimpyclaw/agents/main/HEARTBEAT.md. Follow it strictly. If nothing needs attention, reply HEARTBEAT_OK.',
             tools: {
                 enabled: true,
-                allowedPaths: [
-                    '${HOME}/.skimpyclaw',
-                    input.workspaceDir,
-                ],
+                allowedPaths: ['${HOME}/.skimpyclaw'],
                 maxIterations: 10,
                 bashTimeout: 15000,
                 ...(features.browser ? { browser: { enabled: true } } : { browser: { enabled: false } }),

package/dist/tools.js

@@ -198,6 +198,44 @@ export async function cleanupMcp() {
         mcpRuntime = null;
     }
 }
+async function executeWebSearch(query) {
+    const q = query.trim();
+    if (!q)
+        return 'Error: $web_search requires a non-empty query';
+    const url = `https://api.duckduckgo.com/?q=${encodeURIComponent(q)}&format=json&no_redirect=1&no_html=1&skip_disambig=1`;
+    const res = await fetch(url, { signal: AbortSignal.timeout(8000) });
+    if (!res.ok) {
+        return `Error: web search failed (${res.status} ${res.statusText})`;
+    }
+    const data = await res.json();
+    const lines = [];
+    if (data.AbstractText) {
+        lines.push(`Summary: ${data.AbstractText}`);
+        if (data.AbstractURL) {
+            lines.push(`Source: ${data.AbstractURL}`);
+        }
+    }
+    const related = [];
+    for (const item of data.RelatedTopics || []) {
+        if ('Topics' in item && Array.isArray(item.Topics)) {
+            related.push(...item.Topics);
+        }
+        else {
+            related.push(item);
+        }
+    }
+    const top = related.filter((item) => item.Text && item.FirstURL).slice(0, 5);
+    if (top.length > 0) {
+        lines.push('Top results:');
+        for (const item of top) {
+            lines.push(`- ${item.Text}\n  ${item.FirstURL}`);
+        }
+    }
+    if (lines.length === 0) {
+        return `No web results found for: ${q}`;
+    }
+    return lines.join('\n');
+}
 // --- Tool Executor ---
 export async function executeTool(name, input, config, context) {
     try {
@@ -227,6 +265,10 @@ export async function executeTool(name, input, config, context) {
         // Map Claude Code names to internal names for built-in tools
         const normalized = fromClaudeCodeName(name).toLowerCase().replace(/-/g, '_');
         switch (normalized) {
+            case '$web_search':
+            case 'web_search':
+            case 'websearch':
+                return await executeWebSearch(input.query || input.q || input.text || '');
             case 'read_file':
                 return executeReadFile(input.file_path || input.path, config);
             case 'write_file':

package/dist/voice.js

@@ -187,15 +187,24 @@ function getSTTProvider(config) {
     if (!providers || Object.keys(providers).length === 0) {
         return null;
     }
-    const isApiBackedSttProvider = (provider) => Boolean(provider && (provider.stt || provider.apiKey));
+    const isApiBackedSttProvider = (name, provider) => {
+        if (!provider)
+            return false;
+        // macOS voice provider is TTS-only and must never be used for transcription.
+        const normalizedName = name.trim().toLowerCase();
+        if (normalizedName === 'macos')
+            return false;
+        return Boolean(provider.stt || provider.apiKey);
+    };
     if (config.defaultProvider) {
-        const preferred = providers[config.defaultProvider];
-        if (isApiBackedSttProvider(preferred)) {
+        const preferredName = config.defaultProvider;
+        const preferred = providers[preferredName];
+        if (isApiBackedSttProvider(preferredName, preferred)) {
             return { name: config.defaultProvider, provider: preferred };
         }
     }
     for (const [name, provider] of Object.entries(providers)) {
-        if (isApiBackedSttProvider(provider)) {
+        if (isApiBackedSttProvider(name, provider)) {
             return { name, provider };
         }
     }
@@ -267,6 +276,9 @@ export async function transcribeAudio(audioPath, config) {
     // No local whisper — try API provider directly
     const sttProvider = getSTTProvider(config);
     if (!sttProvider) {
+        if (config.providers?.macos) {
+            throw new Error('No voice transcription provider configured. "macos" is TTS-only. Install local whisper or configure an API STT provider (e.g. openai.stt).');
+        }
         throw new Error('No voice transcription available. Install whisper (pip install openai-whisper) or configure an API provider.');
     }
     return transcribeWithAPI(audioPath, sttProvider.name, sttProvider.provider);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "skimpyclaw",
-  "version": "0.1.7",
+  "version": "0.1.9",
   "description": "Lightweight personal AI assistant with Telegram and Discord integration",
   "type": "module",
   "main": "dist/index.js",