@mseep/claudian 2.0.25

package/tests/unit/core/tools/todo.test.ts

@@ -0,0 +1,227 @@
+import { extractLastTodosFromMessages, parseTodoInput } from '@/core/tools/todo';
+import { TOOL_TODO_WRITE } from '@/core/tools/toolNames';
+
+describe('parseTodoInput', () => {
+  it('should parse valid todo items', () => {
+    const input = {
+      todos: [
+        { content: 'Run tests', status: 'pending', activeForm: 'Running tests' },
+        { content: 'Fix bug', status: 'in_progress', activeForm: 'Fixing bug' },
+        { content: 'Deploy', status: 'completed', activeForm: 'Deploying' },
+      ],
+    };
+
+    const result = parseTodoInput(input);
+
+    expect(result).toHaveLength(3);
+    expect(result![0]).toEqual({ content: 'Run tests', status: 'pending', activeForm: 'Running tests' });
+    expect(result![1].status).toBe('in_progress');
+    expect(result![2].status).toBe('completed');
+  });
+
+  it('should return null when todos key is missing', () => {
+    expect(parseTodoInput({})).toBeNull();
+  });
+
+  it('should return null when todos is not an array', () => {
+    expect(parseTodoInput({ todos: 'not an array' })).toBeNull();
+    expect(parseTodoInput({ todos: 42 })).toBeNull();
+    expect(parseTodoInput({ todos: null })).toBeNull();
+  });
+
+  it('should filter out invalid items', () => {
+    const input = {
+      todos: [
+        { content: 'Valid', status: 'pending', activeForm: 'Working' },
+        { content: '', status: 'pending', activeForm: 'Working' }, // empty content
+        { content: 'No status', activeForm: 'Working' }, // missing status
+        { content: 'Bad status', status: 'unknown', activeForm: 'Working' }, // invalid status
+        null,
+        42,
+        'string',
+      ],
+    };
+
+    const result = parseTodoInput(input);
+
+    expect(result).toHaveLength(1);
+    expect(result![0].content).toBe('Valid');
+  });
+
+  it('should return null when all items are invalid', () => {
+    const input = {
+      todos: [
+        { content: '', status: 'pending', activeForm: 'Working' },
+        null,
+        { status: 'pending' }, // missing content and activeForm
+      ],
+    };
+
+    expect(parseTodoInput(input)).toBeNull();
+  });
+
+  it('should return null for empty todos array', () => {
+    expect(parseTodoInput({ todos: [] })).toBeNull();
+  });
+
+  it('should reject items with missing activeForm', () => {
+    const input = {
+      todos: [
+        { content: 'Task', status: 'pending' }, // no activeForm
+      ],
+    };
+
+    expect(parseTodoInput(input)).toBeNull();
+  });
+
+  it('should reject items with empty activeForm', () => {
+    const input = {
+      todos: [
+        { content: 'Task', status: 'pending', activeForm: '' },
+      ],
+    };
+
+    expect(parseTodoInput(input)).toBeNull();
+  });
+
+  it('should reject non-object items', () => {
+    const input = {
+      todos: [undefined, false, 0],
+    };
+
+    expect(parseTodoInput(input)).toBeNull();
+  });
+});
+
+describe('extractLastTodosFromMessages', () => {
+  it('should extract todos from the last TodoWrite tool call', () => {
+    const messages = [
+      {
+        role: 'user',
+        content: 'Do something',
+      },
+      {
+        role: 'assistant',
+        toolCalls: [
+          {
+            name: TOOL_TODO_WRITE,
+            input: {
+              todos: [
+                { content: 'First', status: 'completed' as const, activeForm: 'First-ing' },
+              ],
+            },
+          },
+        ],
+      },
+      {
+        role: 'assistant',
+        toolCalls: [
+          {
+            name: TOOL_TODO_WRITE,
+            input: {
+              todos: [
+                { content: 'Second', status: 'pending' as const, activeForm: 'Second-ing' },
+              ],
+            },
+          },
+        ],
+      },
+    ];
+
+    const result = extractLastTodosFromMessages(messages);
+
+    expect(result).toHaveLength(1);
+    expect(result![0].content).toBe('Second');
+  });
+
+  it('should return null when no messages exist', () => {
+    expect(extractLastTodosFromMessages([])).toBeNull();
+  });
+
+  it('should return null when no assistant messages have tool calls', () => {
+    const messages = [
+      { role: 'user' },
+      { role: 'assistant' },
+    ];
+
+    expect(extractLastTodosFromMessages(messages)).toBeNull();
+  });
+
+  it('should return null when no TodoWrite tool calls exist', () => {
+    const messages = [
+      {
+        role: 'assistant',
+        toolCalls: [
+          { name: 'Read', input: { file_path: '/test.txt' } },
+        ],
+      },
+    ];
+
+    expect(extractLastTodosFromMessages(messages)).toBeNull();
+  });
+
+  it('should skip user messages', () => {
+    const messages = [
+      {
+        role: 'user',
+        toolCalls: [
+          {
+            name: TOOL_TODO_WRITE,
+            input: {
+              todos: [{ content: 'Should not find', status: 'pending', activeForm: 'Nope' }],
+            },
+          },
+        ],
+      },
+    ];
+
+    expect(extractLastTodosFromMessages(messages)).toBeNull();
+  });
+
+  it('should pick the last TodoWrite within a message with multiple tool calls', () => {
+    const messages = [
+      {
+        role: 'assistant',
+        toolCalls: [
+          {
+            name: TOOL_TODO_WRITE,
+            input: {
+              todos: [{ content: 'Earlier', status: 'pending' as const, activeForm: 'Earlier-ing' }],
+            },
+          },
+          {
+            name: 'Read',
+            input: { file_path: '/test.txt' },
+          },
+          {
+            name: TOOL_TODO_WRITE,
+            input: {
+              todos: [{ content: 'Later', status: 'in_progress' as const, activeForm: 'Later-ing' }],
+            },
+          },
+        ],
+      },
+    ];
+
+    const result = extractLastTodosFromMessages(messages);
+
+    expect(result).toHaveLength(1);
+    expect(result![0].content).toBe('Later');
+  });
+
+  it('should return null when TodoWrite has invalid input', () => {
+    const messages = [
+      {
+        role: 'assistant',
+        toolCalls: [
+          {
+            name: TOOL_TODO_WRITE,
+            input: { todos: 'not-an-array' },
+          },
+        ],
+      },
+    ];
+
+    expect(extractLastTodosFromMessages(messages)).toBeNull();
+  });
+});

package/tests/unit/core/tools/toolIcons.test.ts

@@ -0,0 +1,75 @@
+import { getToolIcon, MCP_ICON_MARKER } from '@/core/tools/toolIcons';
+import {
+  TOOL_AGENT_OUTPUT,
+  TOOL_ASK_USER_QUESTION,
+  TOOL_BASH,
+  TOOL_BASH_OUTPUT,
+  TOOL_EDIT,
+  TOOL_GLOB,
+  TOOL_GREP,
+  TOOL_KILL_SHELL,
+  TOOL_LIST_MCP_RESOURCES,
+  TOOL_LS,
+  TOOL_MCP,
+  TOOL_NOTEBOOK_EDIT,
+  TOOL_READ,
+  TOOL_READ_MCP_RESOURCE,
+  TOOL_SKILL,
+  TOOL_SUBAGENT_LEGACY,
+  TOOL_TASK,
+  TOOL_TODO_WRITE,
+  TOOL_WEB_FETCH,
+  TOOL_WEB_SEARCH,
+  TOOL_WRITE,
+} from '@/core/tools/toolNames';
+
+describe('MCP_ICON_MARKER', () => {
+  it('should be defined as a special marker string', () => {
+    expect(MCP_ICON_MARKER).toBe('__mcp_icon__');
+  });
+});
+
+describe('getToolIcon', () => {
+  it.each([
+    [TOOL_READ, 'file-text'],
+    [TOOL_WRITE, 'file-plus'],
+    [TOOL_EDIT, 'file-pen'],
+    [TOOL_NOTEBOOK_EDIT, 'file-pen'],
+    [TOOL_BASH, 'terminal'],
+    [TOOL_BASH_OUTPUT, 'terminal'],
+    [TOOL_KILL_SHELL, 'terminal'],
+    [TOOL_GLOB, 'folder-search'],
+    [TOOL_GREP, 'search'],
+    [TOOL_LS, 'list'],
+    [TOOL_TODO_WRITE, 'list-checks'],
+    [TOOL_TASK, 'bot'],
+    [TOOL_SUBAGENT_LEGACY, 'bot'],
+    [TOOL_LIST_MCP_RESOURCES, 'list'],
+    [TOOL_READ_MCP_RESOURCE, 'file-text'],
+    [TOOL_MCP, 'wrench'],
+    [TOOL_WEB_SEARCH, 'globe'],
+    [TOOL_WEB_FETCH, 'download'],
+    [TOOL_AGENT_OUTPUT, 'bot'],
+    [TOOL_ASK_USER_QUESTION, 'help-circle'],
+    [TOOL_SKILL, 'zap'],
+  ])('should return "%s" icon for %s tool', (tool, expectedIcon) => {
+    expect(getToolIcon(tool)).toBe(expectedIcon);
+  });
+
+  it('should return MCP_ICON_MARKER for mcp__ prefixed tools', () => {
+    expect(getToolIcon('mcp__server__tool')).toBe(MCP_ICON_MARKER);
+    expect(getToolIcon('mcp__github__search')).toBe(MCP_ICON_MARKER);
+    expect(getToolIcon('mcp__')).toBe(MCP_ICON_MARKER);
+  });
+
+  it('should return fallback wrench icon for unknown tools', () => {
+    expect(getToolIcon('UnknownTool')).toBe('wrench');
+    expect(getToolIcon('')).toBe('wrench');
+    expect(getToolIcon('SomeCustomTool')).toBe('wrench');
+  });
+
+  it('should not match partial mcp prefix', () => {
+    expect(getToolIcon('mcpTool')).toBe('wrench');
+    expect(getToolIcon('mcp_single_underscore')).toBe('wrench');
+  });
+});

package/tests/unit/core/tools/toolInput.test.ts

@@ -0,0 +1,350 @@
+import {
+  extractResolvedAnswers,
+  extractResolvedAnswersFromResultText,
+  getPathFromToolInput,
+} from '@/core/tools/toolInput';
+
+describe('extractResolvedAnswers', () => {
+  it('returns undefined when result is not an object', () => {
+    expect(extractResolvedAnswers('bad')).toBeUndefined();
+    expect(extractResolvedAnswers(123)).toBeUndefined();
+    expect(extractResolvedAnswers(undefined)).toBeUndefined();
+    expect(extractResolvedAnswers(null)).toBeUndefined();
+  });
+
+  it('returns undefined when answers is missing', () => {
+    expect(extractResolvedAnswers({})).toBeUndefined();
+  });
+
+  it('returns undefined when answers is not an object', () => {
+    expect(extractResolvedAnswers({ answers: 'bad' })).toBeUndefined();
+    expect(extractResolvedAnswers({ answers: null })).toBeUndefined();
+    expect(extractResolvedAnswers({ answers: [] })).toBeUndefined();
+  });
+
+  it('normalizes structured answers', () => {
+    const answers = { foo: 'bar', baz: 1, ok: true, choices: ['A', 'B'] };
+    expect(extractResolvedAnswers({ answers })).toEqual({
+      foo: 'bar',
+      baz: '1',
+      ok: 'true',
+      choices: ['A', 'B'],
+    });
+  });
+
+  it('excludes empty-string answers', () => {
+    expect(extractResolvedAnswers({ answers: { q1: 'yes', q2: '' } })).toEqual({ q1: 'yes' });
+  });
+
+  it('returns undefined when all answers are empty strings', () => {
+    expect(extractResolvedAnswers({ answers: { q1: '', q2: '' } })).toBeUndefined();
+  });
+});
+
+describe('extractResolvedAnswersFromResultText', () => {
+  it('returns undefined for non-string or empty values', () => {
+    expect(extractResolvedAnswersFromResultText(undefined)).toBeUndefined();
+    expect(extractResolvedAnswersFromResultText(null)).toBeUndefined();
+    expect(extractResolvedAnswersFromResultText(123)).toBeUndefined();
+    expect(extractResolvedAnswersFromResultText('   ')).toBeUndefined();
+  });
+
+  it('extracts answers from quoted key-value pairs', () => {
+    expect(extractResolvedAnswersFromResultText('"Color?"="Blue" "Size?"="M"')).toEqual({
+      'Color?': 'Blue',
+      'Size?': 'M',
+    });
+  });
+
+  it('extracts answers from JSON object text', () => {
+    expect(extractResolvedAnswersFromResultText('{"Color?":"Blue","Fast?":true}')).toEqual({
+      'Color?': 'Blue',
+      'Fast?': 'true',
+    });
+  });
+
+  it('extracts nested Codex answer objects from JSON result text', () => {
+    expect(extractResolvedAnswersFromResultText('{"answers":{"q1":{"answers":["yes"]}}}')).toEqual({
+      q1: 'yes',
+    });
+  });
+
+  it('preserves multi-answer arrays from JSON result text', () => {
+    expect(extractResolvedAnswersFromResultText('{"answers":{"q1":{"answers":["yes","later"]}}}')).toEqual({
+      q1: ['yes', 'later'],
+    });
+  });
+
+  it('extracts nested answer values from wrapped JSON text', () => {
+    expect(extractResolvedAnswersFromResultText('Result: {"answers":{"q1":{"value":"Blue"}}}')).toEqual({
+      q1: 'Blue',
+    });
+  });
+
+  it('returns undefined when text cannot be parsed', () => {
+    expect(extractResolvedAnswersFromResultText('No parsed answers here')).toBeUndefined();
+  });
+
+  it('excludes empty-string values in JSON object text', () => {
+    expect(extractResolvedAnswersFromResultText('{"Color?":"Blue","Name?":""}')).toEqual({
+      'Color?': 'Blue',
+    });
+  });
+});
+
+describe('getPathFromToolInput', () => {
+  describe('Read tool', () => {
+    it('should extract file_path from Read tool input', () => {
+      const result = getPathFromToolInput('Read', { file_path: '/path/to/file.txt' });
+
+      expect(result).toBe('/path/to/file.txt');
+    });
+
+    it('should return null when file_path is missing', () => {
+      const result = getPathFromToolInput('Read', {});
+
+      expect(result).toBeNull();
+    });
+
+    it('should return null when file_path is empty', () => {
+      const result = getPathFromToolInput('Read', { file_path: '' });
+
+      expect(result).toBeNull();
+    });
+
+    it('should fall back to notebook_path when file_path is empty', () => {
+      const result = getPathFromToolInput('Read', { file_path: '', notebook_path: '/path/to/notebook.ipynb' });
+
+      expect(result).toBe('/path/to/notebook.ipynb');
+    });
+  });
+
+  describe('Write tool', () => {
+    it('should extract file_path from Write tool input', () => {
+      const result = getPathFromToolInput('Write', { file_path: '/path/to/file.txt' });
+
+      expect(result).toBe('/path/to/file.txt');
+    });
+
+    it('should return null when file_path is missing', () => {
+      const result = getPathFromToolInput('Write', { content: 'some content' });
+
+      expect(result).toBeNull();
+    });
+
+    it('should fall back to notebook_path when file_path is missing', () => {
+      const result = getPathFromToolInput('Write', { notebook_path: '/path/to/notebook.ipynb' });
+
+      expect(result).toBe('/path/to/notebook.ipynb');
+    });
+  });
+
+  describe('Edit tool', () => {
+    it('should extract file_path from Edit tool input', () => {
+      const result = getPathFromToolInput('Edit', {
+        file_path: '/path/to/file.txt',
+        old_string: 'old',
+        new_string: 'new',
+      });
+
+      expect(result).toBe('/path/to/file.txt');
+    });
+
+    it('should return null when file_path is missing', () => {
+      const result = getPathFromToolInput('Edit', {
+        old_string: 'old',
+        new_string: 'new',
+      });
+
+      expect(result).toBeNull();
+    });
+
+    it('should fall back to notebook_path when file_path is missing', () => {
+      const result = getPathFromToolInput('Edit', {
+        notebook_path: '/path/to/notebook.ipynb',
+        old_string: 'old',
+        new_string: 'new',
+      });
+
+      expect(result).toBe('/path/to/notebook.ipynb');
+    });
+  });
+
+  describe('NotebookEdit tool', () => {
+    it('should extract file_path from NotebookEdit tool input', () => {
+      const result = getPathFromToolInput('NotebookEdit', {
+        file_path: '/path/to/notebook.ipynb',
+      });
+
+      expect(result).toBe('/path/to/notebook.ipynb');
+    });
+
+    it('should extract notebook_path from NotebookEdit tool input', () => {
+      const result = getPathFromToolInput('NotebookEdit', {
+        notebook_path: '/path/to/notebook.ipynb',
+      });
+
+      expect(result).toBe('/path/to/notebook.ipynb');
+    });
+
+    it('should prefer file_path over notebook_path', () => {
+      const result = getPathFromToolInput('NotebookEdit', {
+        file_path: '/path/via/file_path.ipynb',
+        notebook_path: '/path/via/notebook_path.ipynb',
+      });
+
+      expect(result).toBe('/path/via/file_path.ipynb');
+    });
+
+    it('should return null when both paths are missing', () => {
+      const result = getPathFromToolInput('NotebookEdit', { cell_number: 1 });
+
+      expect(result).toBeNull();
+    });
+  });
+
+  describe('Glob tool', () => {
+    it('should extract path from Glob tool input', () => {
+      const result = getPathFromToolInput('Glob', { path: '/search/path' });
+
+      expect(result).toBe('/search/path');
+    });
+
+    it('should extract pattern as fallback from Glob tool input', () => {
+      const result = getPathFromToolInput('Glob', { pattern: '**/*.ts' });
+
+      expect(result).toBe('**/*.ts');
+    });
+
+    it('should fall back to pattern when path is empty', () => {
+      const result = getPathFromToolInput('Glob', { path: '', pattern: '**/*.ts' });
+
+      expect(result).toBe('**/*.ts');
+    });
+
+    it('should prefer path over pattern', () => {
+      const result = getPathFromToolInput('Glob', {
+        path: '/explicit/path',
+        pattern: '**/*.ts',
+      });
+
+      expect(result).toBe('/explicit/path');
+    });
+
+    it('should return null when both path and pattern are missing', () => {
+      const result = getPathFromToolInput('Glob', {});
+
+      expect(result).toBeNull();
+    });
+  });
+
+  describe('Grep tool', () => {
+    it('should extract path from Grep tool input', () => {
+      const result = getPathFromToolInput('Grep', {
+        path: '/search/path',
+        pattern: 'search-regex',
+      });
+
+      expect(result).toBe('/search/path');
+    });
+
+    it('should return null when path is missing', () => {
+      const result = getPathFromToolInput('Grep', { pattern: 'search-regex' });
+
+      expect(result).toBeNull();
+    });
+
+    it('should not use pattern as path fallback', () => {
+      // Unlike Glob, Grep's pattern is the search regex, not a path
+      const result = getPathFromToolInput('Grep', { pattern: 'search-regex' });
+
+      expect(result).toBeNull();
+    });
+  });
+
+  describe('LS tool', () => {
+    it('should extract path from LS tool input', () => {
+      const result = getPathFromToolInput('LS', { path: '/list/path' });
+
+      expect(result).toBe('/list/path');
+    });
+
+    it('should return null when path is missing', () => {
+      const result = getPathFromToolInput('LS', {});
+
+      expect(result).toBeNull();
+    });
+  });
+
+  describe('unsupported tools', () => {
+    it('should return null for Bash tool', () => {
+      const result = getPathFromToolInput('Bash', { command: 'ls -la' });
+
+      expect(result).toBeNull();
+    });
+
+    it('should return null for Task tool', () => {
+      const result = getPathFromToolInput('Task', { prompt: 'do something' });
+
+      expect(result).toBeNull();
+    });
+
+    it('should return null for WebSearch tool', () => {
+      const result = getPathFromToolInput('WebSearch', { query: 'search term' });
+
+      expect(result).toBeNull();
+    });
+
+    it('should return null for WebFetch tool', () => {
+      const result = getPathFromToolInput('WebFetch', { url: 'https://example.com' });
+
+      expect(result).toBeNull();
+    });
+
+    it('should return null for unknown tool', () => {
+      const result = getPathFromToolInput('UnknownTool', { file_path: '/path' });
+
+      expect(result).toBeNull();
+    });
+
+    it('should return null for empty tool name', () => {
+      const result = getPathFromToolInput('', { file_path: '/path' });
+
+      expect(result).toBeNull();
+    });
+  });
+
+  describe('edge cases', () => {
+    it('should handle paths with spaces', () => {
+      const result = getPathFromToolInput('Read', {
+        file_path: '/path/with spaces/file.txt',
+      });
+
+      expect(result).toBe('/path/with spaces/file.txt');
+    });
+
+    it('should handle Windows-style paths', () => {
+      const result = getPathFromToolInput('Write', {
+        file_path: 'C:\\Users\\test\\file.txt',
+      });
+
+      expect(result).toBe('C:\\Users\\test\\file.txt');
+    });
+
+    it('should handle relative paths', () => {
+      const result = getPathFromToolInput('Edit', {
+        file_path: './relative/path.txt',
+      });
+
+      expect(result).toBe('./relative/path.txt');
+    });
+
+    it('should handle paths starting with tilde', () => {
+      const result = getPathFromToolInput('Read', {
+        file_path: '~/Documents/file.txt',
+      });
+
+      expect(result).toBe('~/Documents/file.txt');
+    });
+  });
+});