@jackwener/opencli 1.7.6 → 1.7.8

package/clis/deepseek/ask.js

@@ -1,5 +1,5 @@
 import { cli, Strategy } from '@jackwener/opencli/registry';
-import { CommandExecutionError } from '@jackwener/opencli/errors';
+import { CliError, CommandExecutionError, EXIT_CODES } from '@jackwener/opencli/errors';
 import {
     DEEPSEEK_DOMAIN, DEEPSEEK_URL, ensureOnDeepSeek, selectModel, setFeature,
     sendMessage, sendWithFile, getBubbleCount, waitForResponse, parseBoolFlag, withRetry,
@@ -23,7 +23,7 @@ export const askCommand = cli({
         { name: 'search', type: 'boolean', default: false, help: 'Enable web search' },
         { name: 'file', help: 'Attach a file (PDF, image, text) with the prompt' },
     ],
-    columns: ['response'],
+    // columns omitted: derived from row keys so non-think output shows only 'response'
 
     func: async (page, kwargs) => {
         const prompt = kwargs.prompt;
@@ -35,29 +35,55 @@ export const askCommand = cli({
             await page.goto(DEEPSEEK_URL);
             await page.wait(3);
         } else {
-            await ensureOnDeepSeek(page);
+            const navigated = await ensureOnDeepSeek(page);
+            if (navigated) {
+                // Workspace was recycled; try to resume the most recent
+                // conversation instead of starting a new one.
+                await page.evaluate(`(() => {
+                    var link = document.querySelector('a[href*="/a/chat/s/"]');
+                    if (link) link.click();
+                })()`);
+                await page.wait(2);
+            }
         }
 
         await page.wait(2);
 
+        // Model selector is only available on the new-chat page, not inside
+        // an existing conversation. Skip it when we resumed a prior thread.
+        const currentUrl = await page.evaluate('window.location.href') || '';
+        const inConversation = currentUrl.includes('/a/chat/s/');
+        const modelExplicit = kwargs.__opencliOptionSources?.model === 'cli';
+
         const wantModel = kwargs.model || 'instant';
-        const modelResult = await withRetry(() => selectModel(page, wantModel));
-        if (!modelResult?.ok) {
-            throw new CommandExecutionError(`Could not switch to ${wantModel} model`);
+        if (inConversation && modelExplicit) {
+            throw new CliError(
+                'ARGUMENT',
+                `Cannot switch to ${wantModel} model inside an existing conversation.`,
+                'Re-run with --new to start a fresh chat before selecting a model.',
+                EXIT_CODES.USAGE_ERROR,
+            );
+        }
+
+        if (!inConversation) {
+            const modelResult = await withRetry(() => selectModel(page, wantModel));
+            if (!modelResult?.ok) {
+                throw new CommandExecutionError(`Could not switch to ${wantModel} model`);
+            }
+            if (modelResult?.toggled) await page.wait(0.5);
         }
-        if (modelResult.toggled) await page.wait(0.5);
 
         const thinkResult = await withRetry(() => setFeature(page, 'DeepThink', wantThink));
-        if (!thinkResult?.ok) {
-            throw new CommandExecutionError('Could not toggle DeepThink');
+        if (!thinkResult?.ok && wantThink) {
+            throw new CommandExecutionError('Could not enable DeepThink');
         }
 
         const searchResult = await withRetry(() => setFeature(page, 'Search', wantSearch));
-        if (!searchResult?.ok) {
-            throw new CommandExecutionError('Could not toggle Search');
+        if (!searchResult?.ok && wantSearch) {
+            throw new CommandExecutionError('Could not enable Search');
         }
 
-        if (thinkResult.toggled || searchResult.toggled) await page.wait(0.5);
+        if (thinkResult?.toggled || searchResult?.toggled) await page.wait(0.5);
 
         if (kwargs.file) {
             const baseline = await withRetry(() => getBubbleCount(page));
@@ -71,11 +97,14 @@ export const askCommand = cli({
                 if (!String(err?.message || err).includes('Promise was collected')) throw err;
             }
             await page.wait(3);
-            const response = await waitForResponse(page, baseline, prompt, timeoutMs);
-            if (!response) {
+            const result = await waitForResponse(page, baseline, prompt, timeoutMs, wantThink);
+            if (!result) {
                 return [{ response: `[NO RESPONSE] No reply within ${kwargs.timeout}s.` }];
             }
-            return [{ response }];
+            if (wantThink && typeof result === 'object' && result.response !== undefined) {
+                return [result];
+            }
+            return [{ response: result }];
         }
 
         const baseline = await withRetry(() => getBubbleCount(page));
@@ -84,11 +113,14 @@ export const askCommand = cli({
             throw new CommandExecutionError(sendResult?.reason || 'Failed to send message');
         }
 
-        const response = await waitForResponse(page, baseline, prompt, timeoutMs);
-        if (!response) {
+        const result = await waitForResponse(page, baseline, prompt, timeoutMs, wantThink);
+        if (!result) {
             return [{ response: `[NO RESPONSE] No reply within ${kwargs.timeout}s.` }];
         }
 
-        return [{ response }];
+        if (wantThink && typeof result === 'object' && result.response !== undefined) {
+            return [result];
+        }
+        return [{ response: result }];
     },
 });

package/clis/deepseek/ask.test.js

@@ -1,4 +1,5 @@
 import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { CliError, CommandExecutionError, EXIT_CODES } from '@jackwener/opencli/errors';
 
 const {
   mockEnsureOnDeepSeek,
@@ -42,11 +43,13 @@ describe('deepseek ask --file', () => {
   const page = {
     wait: vi.fn().mockResolvedValue(undefined),
     goto: vi.fn().mockResolvedValue(undefined),
+    evaluate: vi.fn().mockResolvedValue('https://chat.deepseek.com/'),
   };
 
   beforeEach(() => {
     vi.clearAllMocks();
-    mockEnsureOnDeepSeek.mockResolvedValue(undefined);
+    page.evaluate.mockResolvedValue('https://chat.deepseek.com/');
+    mockEnsureOnDeepSeek.mockResolvedValue(false);
     mockSelectModel.mockResolvedValue({ ok: true, toggled: false });
     mockSetFeature.mockResolvedValue({ ok: true, toggled: false });
     mockSendWithFile.mockResolvedValue({ ok: true });
@@ -68,6 +71,196 @@ describe('deepseek ask --file', () => {
     expect(rows).toEqual([{ response: 'new reply' }]);
     expect(mockGetBubbleCount).toHaveBeenCalledTimes(1);
     expect(mockSendWithFile).toHaveBeenCalledWith(page, './report.pdf', 'summarize this');
-    expect(mockWaitForResponse).toHaveBeenCalledWith(page, 7, 'summarize this', 120000);
+    expect(mockWaitForResponse).toHaveBeenCalledWith(page, 7, 'summarize this', 120000, false);
+  });
+
+  it('still fails when explicit instant model selection cannot be verified', async () => {
+    mockSelectModel.mockResolvedValue({ ok: false });
+
+    await expect(askCommand.func(page, {
+      prompt: 'summarize this',
+      timeout: 120,
+      new: false,
+      model: 'instant',
+      think: false,
+      search: false,
+    })).rejects.toThrow(new CommandExecutionError('Could not switch to instant model'));
+  });
+});
+
+describe('deepseek ask --think', () => {
+  const page = {
+    wait: vi.fn().mockResolvedValue(undefined),
+    goto: vi.fn().mockResolvedValue(undefined),
+    evaluate: vi.fn().mockResolvedValue('https://chat.deepseek.com/'),
+  };
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    page.evaluate.mockResolvedValue('https://chat.deepseek.com/');
+    mockEnsureOnDeepSeek.mockResolvedValue(false);
+    mockSelectModel.mockResolvedValue({ ok: true, toggled: false });
+    mockSetFeature.mockResolvedValue({ ok: true, toggled: false });
+    mockSendMessage.mockResolvedValue({ ok: true });
+    mockGetBubbleCount.mockResolvedValue(5);
+  });
+
+  it('returns separate thinking and response fields when --think is enabled', async () => {
+    mockWaitForResponse.mockResolvedValue({
+      response: 'The answer is 42.',
+      thinking: 'Let me analyze this...',
+      thinking_time: '2.5',
+    });
+
+    const rows = await askCommand.func(page, {
+      prompt: 'what is the answer?',
+      timeout: 120,
+      new: false,
+      model: 'instant',
+      think: true,
+      search: false,
+    });
+
+    expect(rows).toEqual([{
+      response: 'The answer is 42.',
+      thinking: 'Let me analyze this...',
+      thinking_time: '2.5',
+    }]);
+    expect(mockWaitForResponse).toHaveBeenCalledWith(page, 5, 'what is the answer?', 120000, true);
+  });
+
+  it('returns plain response when --think is disabled', async () => {
+    mockWaitForResponse.mockResolvedValue('The answer is 42.');
+
+    const rows = await askCommand.func(page, {
+      prompt: 'what is the answer?',
+      timeout: 120,
+      new: false,
+      model: 'instant',
+      think: false,
+      search: false,
+    });
+
+    expect(rows).toEqual([{ response: 'The answer is 42.' }]);
+    expect(mockWaitForResponse).toHaveBeenCalledWith(page, 5, 'what is the answer?', 120000, false);
+  });
+
+  it('does not declare static columns (derived from row keys)', () => {
+    // columns should be undefined so the renderer infers from row keys,
+    // avoiding empty trailing columns on non-think output.
+    expect(askCommand.columns).toBeUndefined();
+  });
+
+  it('non-think rows only contain response key', async () => {
+    mockWaitForResponse.mockResolvedValue('Plain answer.');
+
+    const rows = await askCommand.func(page, {
+      prompt: 'hello',
+      timeout: 120,
+      new: false,
+      model: 'instant',
+      think: false,
+      search: false,
+    });
+
+    // Row keys drive rendered columns; no thinking/thinking_time present.
+    expect(Object.keys(rows[0])).toEqual(['response']);
+  });
+});
+
+describe('deepseek ask conversation resume', () => {
+  const page = {
+    wait: vi.fn().mockResolvedValue(undefined),
+    goto: vi.fn().mockResolvedValue(undefined),
+    evaluate: vi.fn(),
+  };
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    mockSetFeature.mockResolvedValue({ ok: true, toggled: false });
+    mockSendMessage.mockResolvedValue({ ok: true });
+    mockGetBubbleCount.mockResolvedValue(2);
+    mockWaitForResponse.mockResolvedValue('follow-up reply');
+  });
+
+  it('resumes the most recent conversation and skips model selection', async () => {
+    mockEnsureOnDeepSeek.mockResolvedValue(true);
+    // first evaluate: sidebar resume click (returns undefined)
+    page.evaluate.mockResolvedValueOnce(undefined);
+    // second evaluate: URL check (now inside a conversation)
+    page.evaluate.mockResolvedValueOnce('https://chat.deepseek.com/a/chat/s/abc-123');
+
+    const rows = await askCommand.func(page, {
+      prompt: 'follow up',
+      timeout: 120,
+      new: false,
+      model: 'instant',
+      think: false,
+      search: false,
+    });
+
+    expect(rows).toEqual([{ response: 'follow-up reply' }]);
+    expect(mockSelectModel).not.toHaveBeenCalled();
+    expect(mockSendMessage).toHaveBeenCalled();
+  });
+
+  it('skips model selection when already inside an existing conversation', async () => {
+    mockEnsureOnDeepSeek.mockResolvedValue(false);
+    page.evaluate.mockResolvedValue('https://chat.deepseek.com/a/chat/s/abc-123');
+
+    const rows = await askCommand.func(page, {
+      prompt: 'continue',
+      timeout: 120,
+      new: false,
+      model: 'expert',
+      think: false,
+      search: false,
+    });
+
+    expect(rows).toEqual([{ response: 'follow-up reply' }]);
+    expect(mockSelectModel).not.toHaveBeenCalled();
+  });
+
+  it('fails fast when --model is explicitly requested inside an existing conversation', async () => {
+    mockEnsureOnDeepSeek.mockResolvedValue(false);
+    page.evaluate.mockResolvedValue('https://chat.deepseek.com/a/chat/s/abc-123');
+
+    await expect(askCommand.func(page, {
+      prompt: 'continue',
+      timeout: 120,
+      new: false,
+      model: 'expert',
+      think: false,
+      search: false,
+      __opencliOptionSources: { model: 'cli' },
+    })).rejects.toMatchObject(new CliError(
+      'ARGUMENT',
+      'Cannot switch to expert model inside an existing conversation.',
+      'Re-run with --new to start a fresh chat before selecting a model.',
+      EXIT_CODES.USAGE_ERROR,
+    ));
+
+    expect(mockSelectModel).not.toHaveBeenCalled();
+  });
+
+  it('still selects model when no conversation to resume', async () => {
+    mockEnsureOnDeepSeek.mockResolvedValue(true);
+    mockSelectModel.mockResolvedValue({ ok: true, toggled: false });
+    // first evaluate: sidebar resume click (no link found)
+    page.evaluate.mockResolvedValueOnce(undefined);
+    // second evaluate: URL check (still on root page)
+    page.evaluate.mockResolvedValueOnce('https://chat.deepseek.com/');
+
+    const rows = await askCommand.func(page, {
+      prompt: 'hello',
+      timeout: 120,
+      new: false,
+      model: 'instant',
+      think: false,
+      search: false,
+    });
+
+    expect(rows).toEqual([{ response: 'follow-up reply' }]);
+    expect(mockSelectModel).toHaveBeenCalled();
   });
 });

package/clis/deepseek/utils.js

@@ -15,10 +15,10 @@ export async function isOnDeepSeek(page) {
 }
 
 export async function ensureOnDeepSeek(page) {
-    if (!(await isOnDeepSeek(page))) {
-        await page.goto(DEEPSEEK_URL);
-        await page.wait(3);
-    }
+    if (await isOnDeepSeek(page)) return false;
+    await page.goto(DEEPSEEK_URL);
+    await page.wait(3);
+    return true;
 }
 
 export async function getPageState(page) {
@@ -38,31 +38,27 @@ export async function getPageState(page) {
 
 export async function selectModel(page, modelName) {
     return page.evaluate(`(() => {
-        const radios = document.querySelectorAll('div[role="radio"]');
-        for (const radio of radios) {
-            const span = radio.querySelector('span');
-            if (span && span.textContent.trim().toLowerCase() === '${modelName}'.toLowerCase()) {
-                const alreadySelected = radio.getAttribute('aria-checked') === 'true';
-                if (!alreadySelected) radio.click();
-                return { ok: true, toggled: !alreadySelected };
-            }
-        }
-        return { ok: false };
+        var radios = document.querySelectorAll('div[role="radio"]');
+        if (radios.length === 0) return { ok: false };
+        var isFirst = '${modelName}'.toLowerCase() === 'instant';
+        if (!isFirst && radios.length < 2) return { ok: false };
+        var target = isFirst ? radios[0] : radios[radios.length - 1];
+        var alreadySelected = target.getAttribute('aria-checked') === 'true';
+        if (!alreadySelected) target.click();
+        return { ok: true, toggled: !alreadySelected };
     })()`);
 }
 
 export async function setFeature(page, featureName, enabled) {
+    // Match by position: DeepThink is the first toggle, Search is the second
+    var index = featureName === 'DeepThink' ? 0 : 1;
     return page.evaluate(`(() => {
-        const btns = document.querySelectorAll('div[role="button"]');
-        for (const btn of btns) {
-            const span = btn.querySelector('span');
-            if (span && span.textContent.trim() === '${featureName}') {
-                const isActive = btn.classList.contains('ds-toggle-button--selected');
-                if (${enabled} !== isActive) btn.click();
-                return { ok: true, toggled: ${enabled} !== isActive };
-            }
-        }
-        return { ok: false };
+        var toggles = Array.from(document.querySelectorAll('.ds-toggle-button'));
+        var btn = toggles[${index}];
+        if (!btn) return { ok: false };
+        var isActive = btn.classList.contains('ds-toggle-button--selected');
+        if (${enabled} !== isActive) btn.click();
+        return { ok: true, toggled: ${enabled} !== isActive };
     })()`);
 }
 
@@ -101,7 +97,35 @@ export async function getBubbleCount(page) {
     return count || 0;
 }
 
-export async function waitForResponse(page, baselineCount, prompt, timeoutMs) {
+// Parse thinking response using text as a fallback when DOM-level extraction
+// is not available.  Does NOT split on \n\n — that heuristic silently corrupts
+// multi-paragraph thinking or multi-paragraph answers.  Instead, everything
+// after the header is treated as thinking content, and `response` stays empty
+// until the caller provides a DOM-separated answer.
+export function parseThinkingResponse(rawText) {
+    if (!rawText) return null;
+
+    // Match thinking header patterns: "Thought for X seconds" or "已思考（用时 X 秒）"
+    const thinkHeaderMatch = rawText.match(/^(Thought for ([\d.]+) seconds?|已思考（用时 ([\d.]+) 秒）)\s*/);
+
+    if (!thinkHeaderMatch) {
+        // No thinking section found, return plain response
+        return { response: rawText, thinking: null, thinking_time: null };
+    }
+
+    const thinkingTime = thinkHeaderMatch[2] || thinkHeaderMatch[3];
+    const afterHeader = rawText.slice(thinkHeaderMatch[0].length);
+
+    // Treat everything after the header as thinking.  The response will be
+    // populated by the DOM-level extraction in waitForResponse().
+    return {
+        response: '',
+        thinking: afterHeader.trim(),
+        thinking_time: thinkingTime,
+    };
+}
+
+export async function waitForResponse(page, baselineCount, prompt, timeoutMs, parseThinking = false) {
     const startTime = Date.now();
     let lastText = '';
     let stableCount = 0;
@@ -114,7 +138,51 @@ export async function waitForResponse(page, baselineCount, prompt, timeoutMs) {
             result = await page.evaluate(`(() => {
                 const bubbles = document.querySelectorAll('${MESSAGE_SELECTOR}');
                 const texts = Array.from(bubbles).map(b => (b.innerText || '').trim()).filter(Boolean);
-                return { count: texts.length, last: texts[texts.length - 1] || '' };
+                var last = texts[texts.length - 1] || '';
+
+                // DOM-level thinking/response separation.
+                // DeepSeek renders thinking in a collapsible container with a
+                // distinct class (e.g. .ds-markdown--think or similar) and the
+                // final answer in the main .ds-markdown region.  By querying
+                // these separately we avoid any text-heuristic split.
+                var thinkEl = null, answerEl = null, thinkTime = null;
+                if (${parseThinking} && bubbles.length > 0) {
+                    var lastBubble = bubbles[bubbles.length - 1];
+                    // Thinking container — DeepSeek uses various class names;
+                    // try common selectors.
+                    thinkEl = lastBubble.querySelector('.ds-markdown--think')
+                           || lastBubble.querySelector('[class*="think"]');
+                    // Final answer container — the main markdown block that is
+                    // NOT the thinking section.
+                    var markdownEls = lastBubble.querySelectorAll('.ds-markdown');
+                    for (var i = 0; i < markdownEls.length; i++) {
+                        if (markdownEls[i] !== thinkEl
+                            && !(thinkEl && thinkEl.contains(markdownEls[i]))
+                            && !markdownEls[i].classList.contains('ds-markdown--think')) {
+                            answerEl = markdownEls[i];
+                        }
+                    }
+                    // Thinking time from the toggle/header element
+                    var timeEl = lastBubble.querySelector('[class*="think"] ~ *')
+                              || lastBubble.querySelector('.ds-thinking-header');
+                    if (!timeEl) {
+                        // Fallback: parse from raw text header
+                        var m = last.match(/^(?:Thought for ([\\d.]+) seconds?|已思考（用时 ([\\d.]+) 秒）)/);
+                        if (m) thinkTime = m[1] || m[2];
+                    } else {
+                        var tm = (timeEl.textContent || '').match(/([\\d.]+)/);
+                        if (tm) thinkTime = tm[1];
+                    }
+                }
+
+                return {
+                    count: texts.length,
+                    last: last,
+                    // DOM-separated fields (null when not available)
+                    thinkText: thinkEl ? (thinkEl.innerText || '').trim() : null,
+                    answerText: answerEl ? (answerEl.innerText || '').trim() : null,
+                    thinkTime: thinkTime,
+                };
             })()`);
         } catch {
             continue;
@@ -126,7 +194,21 @@ export async function waitForResponse(page, baselineCount, prompt, timeoutMs) {
         if (candidate && result.count > baselineCount && candidate !== prompt.trim()) {
             if (candidate === lastText) {
                 stableCount++;
-                if (stableCount >= 3) return candidate;
+                if (stableCount >= 3) {
+                    if (parseThinking) {
+                        // Prefer DOM-level separation
+                        if (result.thinkText != null || result.answerText != null) {
+                            return {
+                                thinking: result.thinkText || '',
+                                response: result.answerText || '',
+                                thinking_time: result.thinkTime || null,
+                            };
+                        }
+                        // Fallback to text-header parsing (no \n\n split)
+                        return parseThinkingResponse(candidate);
+                    }
+                    return candidate;
+                }
             } else {
                 stableCount = 0;
             }
@@ -134,6 +216,9 @@ export async function waitForResponse(page, baselineCount, prompt, timeoutMs) {
         }
     }
 
+    if (parseThinking && lastText) {
+        return parseThinkingResponse(lastText);
+    }
     return lastText || null;
 }
 
@@ -167,8 +252,7 @@ export async function getConversationList(page) {
             const items = [];
             const links = document.querySelectorAll('a[href*="/a/chat/s/"]');
             links.forEach((link, i) => {
-                const titleEl = link.querySelector('div');
-                const title = titleEl ? titleEl.textContent.trim() : '';
+                const title = (link.innerText || '').trim().split('\\n')[0].trim();
                 const href = link.getAttribute('href') || '';
                 const idMatch = href.match(/\\/s\\/([a-f0-9-]+)/);
                 items.push({

package/clis/deepseek/utils.test.js

@@ -2,7 +2,90 @@ import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
 import { afterEach, describe, expect, it, vi } from 'vitest';
-import { sendWithFile } from './utils.js';
+import { selectModel, sendWithFile, parseThinkingResponse } from './utils.js';
+
+describe('deepseek parseThinkingResponse', () => {
+  it('returns plain response when no thinking header is present', () => {
+    const rawText = 'This is a regular response without thinking.';
+    const result = parseThinkingResponse(rawText);
+
+    expect(result).toEqual({
+      response: rawText,
+      thinking: null,
+      thinking_time: null,
+    });
+  });
+
+  it('parses English thinking header — all content after header is thinking', () => {
+    const rawText = 'Thought for 3.5 seconds\n\nLet me analyze this problem...\nFirst, I need to consider X.\nThen, Y.\n\nThe answer is 42.';
+    const result = parseThinkingResponse(rawText);
+
+    // Text-level parser no longer splits on \n\n; everything after header is thinking.
+    // DOM-level extraction in waitForResponse() handles the actual separation.
+    expect(result).toEqual({
+      response: '',
+      thinking: 'Let me analyze this problem...\nFirst, I need to consider X.\nThen, Y.\n\nThe answer is 42.',
+      thinking_time: '3.5',
+    });
+  });
+
+  it('parses Chinese thinking header — all content after header is thinking', () => {
+    const rawText = '已思考（用时 2.3 秒）\n\n让我分析这个问题...\n首先需要考虑X。\n然后是Y。\n\n答案是42。';
+    const result = parseThinkingResponse(rawText);
+
+    expect(result).toEqual({
+      response: '',
+      thinking: '让我分析这个问题...\n首先需要考虑X。\n然后是Y。\n\n答案是42。',
+      thinking_time: '2.3',
+    });
+  });
+
+  it('multi-paragraph thinking without final answer is not corrupted', () => {
+    const rawText = 'Thought for 1.2 seconds\n\nFirst paragraph.\n\nSecond paragraph.';
+    const result = parseThinkingResponse(rawText);
+
+    // Both paragraphs must stay in thinking; response is empty.
+    expect(result).toEqual({
+      response: '',
+      thinking: 'First paragraph.\n\nSecond paragraph.',
+      thinking_time: '1.2',
+    });
+  });
+
+  it('multi-paragraph final answer is not split by text parser', () => {
+    const rawText = 'Thought for 3 seconds\n\nreasoning\n\nAnswer para 1.\n\nAnswer para 2.';
+    const result = parseThinkingResponse(rawText);
+
+    // Text parser treats everything as thinking; DOM handles separation.
+    expect(result).toEqual({
+      response: '',
+      thinking: 'reasoning\n\nAnswer para 1.\n\nAnswer para 2.',
+      thinking_time: '3',
+    });
+  });
+
+  it('handles thinking without final response', () => {
+    const rawText = 'Thought for 1.2 seconds\n\nThinking process here...';
+    const result = parseThinkingResponse(rawText);
+
+    expect(result).toEqual({
+      response: '',
+      thinking: 'Thinking process here...',
+      thinking_time: '1.2',
+    });
+  });
+
+  it('returns null for empty input', () => {
+    const result = parseThinkingResponse('');
+    expect(result).toBeNull();
+  });
+
+  it('returns null for null input', () => {
+    const result = parseThinkingResponse(null);
+    expect(result).toBeNull();
+  });
+});
+
 
 describe('deepseek sendWithFile', () => {
   const tempDirs = [];
@@ -35,3 +118,28 @@ describe('deepseek sendWithFile', () => {
     expect(page.setFileInput).toHaveBeenCalledWith([filePath], 'input[type="file"]');
   });
 });
+
+describe('deepseek selectModel', () => {
+  afterEach(() => {
+    vi.restoreAllMocks();
+    delete global.document;
+  });
+
+  it('fails expert selection when only one radio is present', async () => {
+    const instantRadio = {
+      getAttribute: vi.fn(() => 'true'),
+      click: vi.fn(),
+    };
+    global.document = {
+      querySelectorAll: vi.fn(() => [instantRadio]),
+    };
+    const page = {
+      evaluate: vi.fn(async (script) => eval(script)),
+    };
+
+    const result = await selectModel(page, 'expert');
+
+    expect(result).toEqual({ ok: false });
+    expect(instantRadio.click).not.toHaveBeenCalled();
+  });
+});

package/clis/gemini/image.js

@@ -57,7 +57,7 @@ export const imageCommand = cli({
         { name: 'prompt', positional: true, required: true, help: 'Image prompt to send to Gemini' },
         { name: 'rt', default: '1:1', help: 'Ratio shorthand for aspect ratio (1:1, 16:9, 9:16, 4:3, 3:4, 3:2, 2:3)' },
         { name: 'st', default: '', help: 'Style shorthand, e.g. anime, icon, watercolor' },
-        { name: 'op', default: path.join(os.homedir(), 'tmp', 'gemini-images'), help: 'Output directory shorthand' },
+        { name: 'op', default: '~/tmp/gemini-images', help: 'Output directory shorthand' },
         { name: 'sd', type: 'boolean', default: false, help: 'Skip download shorthand; only show Gemini page link' },
     ],
     columns: ['status', 'file', 'link'],

package/clis/instagram/download.js

@@ -202,7 +202,7 @@ cli({
     navigateBefore: false,
     args: [
         { name: 'url', positional: true, required: true, help: 'Instagram post / reel / tv URL' },
-        { name: 'path', default: path.join(os.homedir(), 'Downloads', 'Instagram'), help: 'Download directory' },
+        { name: 'path', default: '~/Downloads/Instagram', help: 'Download directory' },
     ],
     func: async (page, kwargs) => {
         const browserPage = ensurePage(page);