@mseep/claudian 2.0.25

package/tests/unit/utils/context.test.ts

@@ -0,0 +1,288 @@
+import {
+  appendContextFiles,
+  appendCurrentNote,
+  extractContentBeforeXmlContext,
+  extractUserDisplayContent,
+  extractUserQuery,
+  formatCurrentNote,
+  stripCurrentNoteContext,
+  XML_CONTEXT_PATTERN,
+} from '../../../src/utils/context';
+
+describe('formatCurrentNote', () => {
+  it('formats note path in XML tags', () => {
+    expect(formatCurrentNote('notes/test.md')).toBe(
+      '<current_note>\nnotes/test.md\n</current_note>'
+    );
+  });
+
+  it('handles paths with special characters', () => {
+    expect(formatCurrentNote('notes/my file (1).md')).toBe(
+      '<current_note>\nnotes/my file (1).md\n</current_note>'
+    );
+  });
+});
+
+describe('appendCurrentNote', () => {
+  it('appends current note to prompt with double newline separator', () => {
+    const result = appendCurrentNote('Hello', 'notes/test.md');
+    expect(result).toBe(
+      'Hello\n\n<current_note>\nnotes/test.md\n</current_note>'
+    );
+  });
+
+  it('preserves original prompt content', () => {
+    const result = appendCurrentNote('Multi\nline\nprompt', 'test.md');
+    expect(result.startsWith('Multi\nline\nprompt\n\n')).toBe(true);
+  });
+});
+
+describe('stripCurrentNoteContext', () => {
+  describe('legacy prefix format', () => {
+    it('strips current_note from start of prompt', () => {
+      const prompt = '<current_note>\nnotes/test.md\n</current_note>\n\nUser query here';
+      expect(stripCurrentNoteContext(prompt)).toBe('User query here');
+    });
+
+    it('handles multiline note content in prefix', () => {
+      const prompt = '<current_note>\npath/to/note.md\nwith extra info\n</current_note>\n\nQuery';
+      expect(stripCurrentNoteContext(prompt)).toBe('Query');
+    });
+  });
+
+  describe('current suffix format', () => {
+    it('strips current_note from end of prompt', () => {
+      const prompt = 'User query here\n\n<current_note>\nnotes/test.md\n</current_note>';
+      expect(stripCurrentNoteContext(prompt)).toBe('User query here');
+    });
+
+    it('handles multiline note content in suffix', () => {
+      const prompt = 'Query\n\n<current_note>\npath/to/note.md\n</current_note>';
+      expect(stripCurrentNoteContext(prompt)).toBe('Query');
+    });
+  });
+
+  it('returns unchanged prompt when no current_note present', () => {
+    const prompt = 'Just a regular prompt';
+    expect(stripCurrentNoteContext(prompt)).toBe('Just a regular prompt');
+  });
+
+  it('prefers prefix format when both could match', () => {
+    // This tests the function order: it tries prefix first
+    const prefixPrompt = '<current_note>\ntest.md\n</current_note>\n\nQuery';
+    expect(stripCurrentNoteContext(prefixPrompt)).toBe('Query');
+  });
+});
+
+describe('XML_CONTEXT_PATTERN', () => {
+  it('matches current_note tag', () => {
+    const text = 'Query\n\n<current_note>\ntest.md\n</current_note>';
+    expect(XML_CONTEXT_PATTERN.test(text)).toBe(true);
+  });
+
+  it('matches editor_selection tag with attributes', () => {
+    const text = 'Query\n\n<editor_selection path="test.md">\nselected text\n</editor_selection>';
+    expect(XML_CONTEXT_PATTERN.test(text)).toBe(true);
+  });
+
+  it('matches editor_cursor tag', () => {
+    const text = 'Query\n\n<editor_cursor path="test.md">\n</editor_cursor>';
+    expect(XML_CONTEXT_PATTERN.test(text)).toBe(true);
+  });
+
+  it('matches context_files tag', () => {
+    const text = 'Query\n\n<context_files>\nfile1.md, file2.md\n</context_files>';
+    expect(XML_CONTEXT_PATTERN.test(text)).toBe(true);
+  });
+
+  it('matches canvas_selection tag', () => {
+    const text = 'Query\n\n<canvas_selection path="my.canvas">\nnode1, node2\n</canvas_selection>';
+    expect(XML_CONTEXT_PATTERN.test(text)).toBe(true);
+  });
+
+  it('matches browser_selection tag', () => {
+    const text = 'Query\n\n<browser_selection source="surfing-view">\nselected web content\n</browser_selection>';
+    expect(XML_CONTEXT_PATTERN.test(text)).toBe(true);
+  });
+
+  it('does not match without double newline separator', () => {
+    const text = 'Query\n<current_note>\ntest.md\n</current_note>';
+    expect(XML_CONTEXT_PATTERN.test(text)).toBe(false);
+  });
+
+  it('does not match other XML tags', () => {
+    const text = 'Query\n\n<other_tag>\ncontent\n</other_tag>';
+    expect(XML_CONTEXT_PATTERN.test(text)).toBe(false);
+  });
+});
+
+describe('extractContentBeforeXmlContext', () => {
+  describe('legacy format with <query> tags', () => {
+    it('extracts content from query tags', () => {
+      const prompt = '<current_note>\ntest.md\n</current_note>\n\n<query>\nUser question\n</query>';
+      expect(extractContentBeforeXmlContext(prompt)).toBe('User question');
+    });
+
+    it('trims whitespace from extracted content', () => {
+      const prompt = '<query>\n  spaced content  \n</query>';
+      expect(extractContentBeforeXmlContext(prompt)).toBe('spaced content');
+    });
+
+    it('handles multiline content in query tags', () => {
+      const prompt = '<query>\nLine 1\nLine 2\nLine 3\n</query>';
+      expect(extractContentBeforeXmlContext(prompt)).toBe('Line 1\nLine 2\nLine 3');
+    });
+  });
+
+  describe('current format with user content first', () => {
+    it('extracts content before current_note tag', () => {
+      const prompt = 'User query\n\n<current_note>\ntest.md\n</current_note>';
+      expect(extractContentBeforeXmlContext(prompt)).toBe('User query');
+    });
+
+    it('extracts content before editor_selection tag', () => {
+      const prompt = 'Edit this\n\n<editor_selection path="test.md">\nselected\n</editor_selection>';
+      expect(extractContentBeforeXmlContext(prompt)).toBe('Edit this');
+    });
+
+    it('extracts content before editor_cursor tag', () => {
+      const prompt = 'Insert here\n\n<editor_cursor path="test.md">\n</editor_cursor>';
+      expect(extractContentBeforeXmlContext(prompt)).toBe('Insert here');
+    });
+
+    it('extracts content before context_files tag', () => {
+      const prompt = 'Use these files\n\n<context_files>\nfile1.md\n</context_files>';
+      expect(extractContentBeforeXmlContext(prompt)).toBe('Use these files');
+    });
+
+    it('handles multiple context tags - extracts before first one', () => {
+      const prompt = 'Query\n\n<current_note>\ntest.md\n</current_note>\n\n<editor_selection path="x">\ny\n</editor_selection>';
+      expect(extractContentBeforeXmlContext(prompt)).toBe('Query');
+    });
+
+    it('extracts content before browser_selection tag', () => {
+      const prompt = 'Summarize this\n\n<browser_selection source="surfing-view">\nselected web content\n</browser_selection>';
+      expect(extractContentBeforeXmlContext(prompt)).toBe('Summarize this');
+    });
+
+    it('trims whitespace from extracted content', () => {
+      const prompt = '  spaced query  \n\n<current_note>\ntest.md\n</current_note>';
+      expect(extractContentBeforeXmlContext(prompt)).toBe('spaced query');
+    });
+  });
+
+  describe('edge cases', () => {
+    it('returns undefined for empty string', () => {
+      expect(extractContentBeforeXmlContext('')).toBeUndefined();
+    });
+
+    it('returns undefined for plain text without XML context', () => {
+      expect(extractContentBeforeXmlContext('Just a plain prompt')).toBeUndefined();
+    });
+
+    it('returns undefined for null-ish input', () => {
+      expect(extractContentBeforeXmlContext(null as unknown as string)).toBeUndefined();
+      expect(extractContentBeforeXmlContext(undefined as unknown as string)).toBeUndefined();
+    });
+  });
+});
+
+describe('extractUserDisplayContent', () => {
+  it('extracts display content before XML context tags', () => {
+    expect(extractUserDisplayContent('Summarize this\n\n<current_note>\nnotes/today.md\n</current_note>'))
+      .toBe('Summarize this');
+  });
+
+  it('extracts display content before bracket context tags', () => {
+    expect(extractUserDisplayContent('Fix the bug\n[Current note: notes/bug.md]'))
+      .toBe('Fix the bug');
+  });
+
+  it('does not hide ordinary XML-like user text', () => {
+    expect(extractUserDisplayContent('What does <xml> mean?')).toBeUndefined();
+  });
+});
+
+describe('extractUserQuery', () => {
+  describe('with XML context (delegates to extractContentBeforeXmlContext)', () => {
+    it('extracts content from legacy query tags', () => {
+      const prompt = '<current_note>\ntest.md\n</current_note>\n\n<query>\nUser question\n</query>';
+      expect(extractUserQuery(prompt)).toBe('User question');
+    });
+
+    it('extracts content before XML context tags', () => {
+      const prompt = 'User query\n\n<current_note>\ntest.md\n</current_note>';
+      expect(extractUserQuery(prompt)).toBe('User query');
+    });
+  });
+
+  describe('fallback tag stripping', () => {
+    it('strips current_note tags without structured format', () => {
+      // Tag and trailing whitespace are replaced, leaving single space
+      const prompt = 'Query <current_note>test.md</current_note> continues';
+      expect(extractUserQuery(prompt)).toBe('Query continues');
+    });
+
+    it('strips editor_selection tags', () => {
+      const prompt = 'Query <editor_selection path="x">text</editor_selection> end';
+      expect(extractUserQuery(prompt)).toBe('Query end');
+    });
+
+    it('strips editor_cursor tags', () => {
+      const prompt = 'Query <editor_cursor path="x"></editor_cursor> end';
+      expect(extractUserQuery(prompt)).toBe('Query end');
+    });
+
+    it('strips context_files tags', () => {
+      const prompt = 'Query <context_files>file.md</context_files> end';
+      expect(extractUserQuery(prompt)).toBe('Query end');
+    });
+
+    it('strips canvas_selection tags', () => {
+      const prompt = 'Query <canvas_selection path="x.canvas">node1</canvas_selection> end';
+      expect(extractUserQuery(prompt)).toBe('Query end');
+    });
+
+    it('strips browser_selection tags', () => {
+      const prompt = 'Query <browser_selection source="surfing-view">selection</browser_selection> end';
+      expect(extractUserQuery(prompt)).toBe('Query end');
+    });
+
+    it('strips multiple tag types', () => {
+      const prompt = '<current_note>a.md</current_note>Query<context_files>b.md</context_files>';
+      expect(extractUserQuery(prompt)).toBe('Query');
+    });
+  });
+
+  describe('edge cases', () => {
+    it('returns empty string for empty input', () => {
+      expect(extractUserQuery('')).toBe('');
+    });
+
+    it('returns empty string for null-ish input', () => {
+      expect(extractUserQuery(null as unknown as string)).toBe('');
+      expect(extractUserQuery(undefined as unknown as string)).toBe('');
+    });
+
+    it('returns trimmed plain text when no tags present', () => {
+      expect(extractUserQuery('  plain query  ')).toBe('plain query');
+    });
+  });
+});
+
+describe('appendContextFiles', () => {
+  it('appends context files in XML format', () => {
+    const result = appendContextFiles('Query', ['file1.md', 'file2.md']);
+    expect(result).toBe('Query\n\n<context_files>\nfile1.md, file2.md\n</context_files>');
+  });
+
+  it('handles single file', () => {
+    const result = appendContextFiles('Query', ['single.md']);
+    expect(result).toBe('Query\n\n<context_files>\nsingle.md\n</context_files>');
+  });
+
+  it('handles empty file array', () => {
+    const result = appendContextFiles('Query', []);
+    expect(result).toBe('Query\n\n<context_files>\n\n</context_files>');
+  });
+});

package/tests/unit/utils/contextMentionResolver.test.ts

@@ -0,0 +1,270 @@
+import {
+  buildExternalContextLookup,
+  createExternalContextLookupGetter,
+  findBestMentionLookupMatch,
+  isMentionStart,
+  normalizeForPlatformLookup,
+  normalizeMentionPath,
+  resolveExternalMentionAtIndex,
+} from '@/utils/contextMentionResolver';
+import type { ExternalContextDisplayEntry } from '@/utils/externalContext';
+import type { ExternalContextFile } from '@/utils/externalContextScanner';
+
+describe('contextMentionResolver', () => {
+  describe('isMentionStart', () => {
+    it('returns true when @ is at the beginning of text', () => {
+      expect(isMentionStart('@note.md', 0)).toBe(true);
+    });
+
+    it('returns true when @ is preceded by whitespace', () => {
+      expect(isMentionStart('check @note.md', 6)).toBe(true);
+      expect(isMentionStart('check\n@note.md', 6)).toBe(true);
+    });
+
+    it('returns false when @ is not preceded by whitespace', () => {
+      expect(isMentionStart('email@test.com', 5)).toBe(false);
+    });
+
+    it('returns false when the index is not @', () => {
+      expect(isMentionStart('hello', 0)).toBe(false);
+    });
+  });
+
+  describe('normalizeMentionPath', () => {
+    it('normalizes separators and trims leading/trailing slashes', () => {
+      expect(normalizeMentionPath('./src\\folder//file.md/')).toBe('src/folder/file.md');
+    });
+
+    it('returns empty string for root-like input', () => {
+      expect(normalizeMentionPath('./')).toBe('');
+    });
+  });
+
+  describe('normalizeForPlatformLookup', () => {
+    const originalPlatform = process.platform;
+
+    afterEach(() => {
+      Object.defineProperty(process, 'platform', { value: originalPlatform });
+    });
+
+    it('lowercases lookup keys on Windows', () => {
+      Object.defineProperty(process, 'platform', { value: 'win32' });
+      expect(normalizeForPlatformLookup('SRC/FILE.MD')).toBe('src/file.md');
+    });
+
+    it('keeps lookup keys unchanged on non-Windows platforms', () => {
+      Object.defineProperty(process, 'platform', { value: 'darwin' });
+      expect(normalizeForPlatformLookup('SRC/FILE.MD')).toBe('SRC/FILE.MD');
+    });
+  });
+
+  describe('buildExternalContextLookup', () => {
+    it('normalizes keys and keeps the first file for duplicate paths', () => {
+      const files: ExternalContextFile[] = [
+        {
+          path: '/external/src/file.md',
+          name: 'file.md',
+          relativePath: 'src/file.md',
+          contextRoot: '/external',
+          mtime: 1,
+        },
+        {
+          path: '/external/src/file-duplicate.md',
+          name: 'file-duplicate.md',
+          relativePath: './src\\file.md',
+          contextRoot: '/external',
+          mtime: 2,
+        },
+        {
+          path: '/external/ignored',
+          name: 'ignored',
+          relativePath: './',
+          contextRoot: '/external',
+          mtime: 3,
+        },
+      ];
+
+      const lookup = buildExternalContextLookup(files);
+      expect(lookup.size).toBe(1);
+      expect(lookup.get(normalizeForPlatformLookup('src/file.md'))).toBe('/external/src/file.md');
+    });
+  });
+
+  describe('createExternalContextLookupGetter', () => {
+    it('calls getContextFiles on first access for a context root', () => {
+      const filesByRoot: Record<string, ExternalContextFile[]> = {
+        '/external-a': [
+          {
+            path: '/external-a/src/a.md',
+            name: 'a.md',
+            relativePath: 'src/a.md',
+            contextRoot: '/external-a',
+            mtime: 1,
+          },
+        ],
+      };
+      const getContextFiles = jest.fn((contextRoot: string) => filesByRoot[contextRoot] ?? []);
+      const getLookup = createExternalContextLookupGetter(getContextFiles);
+
+      const lookup = getLookup('/external-a');
+
+      expect(getContextFiles).toHaveBeenCalledTimes(1);
+      expect(getContextFiles).toHaveBeenCalledWith('/external-a');
+      expect(lookup.get(normalizeForPlatformLookup('src/a.md'))).toBe('/external-a/src/a.md');
+    });
+
+    it('reuses cached lookup and skips rescanning for the same root', () => {
+      const filesByRoot: Record<string, ExternalContextFile[]> = {
+        '/external-a': [
+          {
+            path: '/external-a/src/a.md',
+            name: 'a.md',
+            relativePath: 'src/a.md',
+            contextRoot: '/external-a',
+            mtime: 1,
+          },
+        ],
+      };
+      const getContextFiles = jest.fn((contextRoot: string) => filesByRoot[contextRoot] ?? []);
+      const getLookup = createExternalContextLookupGetter(getContextFiles);
+
+      const firstLookup = getLookup('/external-a');
+      const secondLookup = getLookup('/external-a');
+
+      expect(getContextFiles).toHaveBeenCalledTimes(1);
+      expect(secondLookup).toBe(firstLookup);
+    });
+
+    it('creates independent cached lookups for distinct roots', () => {
+      const filesByRoot: Record<string, ExternalContextFile[]> = {
+        '/external-a': [
+          {
+            path: '/external-a/src/a.md',
+            name: 'a.md',
+            relativePath: 'src/a.md',
+            contextRoot: '/external-a',
+            mtime: 1,
+          },
+        ],
+        '/external-b': [
+          {
+            path: '/external-b/src/b.md',
+            name: 'b.md',
+            relativePath: 'src/b.md',
+            contextRoot: '/external-b',
+            mtime: 2,
+          },
+        ],
+      };
+      const getContextFiles = jest.fn((contextRoot: string) => filesByRoot[contextRoot] ?? []);
+      const getLookup = createExternalContextLookupGetter(getContextFiles);
+
+      const firstLookup = getLookup('/external-a');
+      const secondLookup = getLookup('/external-b');
+
+      expect(getContextFiles).toHaveBeenCalledTimes(2);
+      expect(getContextFiles).toHaveBeenNthCalledWith(1, '/external-a');
+      expect(getContextFiles).toHaveBeenNthCalledWith(2, '/external-b');
+      expect(firstLookup).not.toBe(secondLookup);
+      expect(firstLookup.get(normalizeForPlatformLookup('src/a.md'))).toBe('/external-a/src/a.md');
+      expect(secondLookup.get(normalizeForPlatformLookup('src/b.md'))).toBe('/external-b/src/b.md');
+    });
+  });
+
+  describe('findBestMentionLookupMatch', () => {
+    it('matches the longest path and preserves trailing punctuation', () => {
+      const text = 'Check @src/my file.md, then continue';
+      const pathStart = text.indexOf('@') + 1;
+      const lookup = new Map<string, string>([
+        ['src/my', '/vault/src/my'],
+        ['src/my file.md', '/vault/src/my file.md'],
+      ]);
+
+      const match = findBestMentionLookupMatch(
+        text,
+        pathStart,
+        lookup,
+        normalizeMentionPath,
+        normalizeForPlatformLookup
+      );
+
+      expect(match).toEqual({
+        resolvedPath: '/vault/src/my file.md',
+        endIndex: text.indexOf(',') + 1,
+        trailingPunctuation: ',',
+      });
+    });
+
+    it('returns null when no lookup key matches', () => {
+      const text = 'Check @missing/path';
+      const pathStart = text.indexOf('@') + 1;
+      const lookup = new Map<string, string>([['src/file.md', '/vault/src/file.md']]);
+
+      const match = findBestMentionLookupMatch(
+        text,
+        pathStart,
+        lookup,
+        normalizeMentionPath,
+        normalizeForPlatformLookup
+      );
+
+      expect(match).toBeNull();
+    });
+  });
+
+  describe('resolveExternalMentionAtIndex', () => {
+    it('resolves external mention with trailing punctuation', () => {
+      const text = 'Use @external/src/app.md.';
+      const mentionStart = text.indexOf('@');
+      const contextEntries: ExternalContextDisplayEntry[] = [
+        {
+          contextRoot: '/external',
+          displayName: 'external',
+          displayNameLower: 'external',
+        },
+      ];
+
+      const getContextLookup = jest.fn().mockReturnValue(
+        new Map<string, string>([['src/app.md', '/external/src/app.md']])
+      );
+
+      const match = resolveExternalMentionAtIndex(
+        text,
+        mentionStart,
+        contextEntries,
+        getContextLookup
+      );
+
+      expect(match).toEqual({
+        resolvedPath: '/external/src/app.md',
+        trailingPunctuation: '.',
+        endIndex: text.length,
+      });
+      expect(getContextLookup).toHaveBeenCalledWith('/external');
+    });
+
+    it('returns null when mention does not include a path separator after display name', () => {
+      const text = 'Use @external and continue';
+      const mentionStart = text.indexOf('@');
+      const contextEntries: ExternalContextDisplayEntry[] = [
+        {
+          contextRoot: '/external',
+          displayName: 'external',
+          displayNameLower: 'external',
+        },
+      ];
+
+      const getContextLookup = jest.fn().mockReturnValue(new Map<string, string>());
+
+      const match = resolveExternalMentionAtIndex(
+        text,
+        mentionStart,
+        contextEntries,
+        getContextLookup
+      );
+
+      expect(match).toBeNull();
+      expect(getContextLookup).not.toHaveBeenCalled();
+    });
+  });
+});

package/tests/unit/utils/date.test.ts

@@ -0,0 +1,80 @@
+import { formatDurationMmSs, getTodayDate } from '../../../src/utils/date';
+
+describe('getTodayDate', () => {
+  it('returns readable date with ISO suffix', () => {
+    const result = getTodayDate();
+    expect(result).toMatch(/\(\d{4}-\d{2}-\d{2}\)$/);
+  });
+
+  it('includes day of week and full date', () => {
+    const result = getTodayDate();
+    const days = ['Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday'];
+    const months = ['January', 'February', 'March', 'April', 'May', 'June',
+      'July', 'August', 'September', 'October', 'November', 'December'];
+    const now = new Date();
+    expect(result).toContain(days[now.getDay()]);
+    expect(result).toContain(months[now.getMonth()]);
+    expect(result).toContain(String(now.getFullYear()));
+  });
+
+  it('ISO portion matches current date', () => {
+    const result = getTodayDate();
+    const isoMatch = result.match(/\((\d{4}-\d{2}-\d{2})\)/);
+    expect(isoMatch).not.toBeNull();
+    const today = new Date().toISOString().split('T')[0];
+    expect(isoMatch![1]).toBe(today);
+  });
+});
+
+describe('formatDurationMmSs', () => {
+  it('formats 0 seconds as 0s', () => {
+    expect(formatDurationMmSs(0)).toBe('0s');
+  });
+
+  it('formats 59 seconds as 59s', () => {
+    expect(formatDurationMmSs(59)).toBe('59s');
+  });
+
+  it('formats 60 seconds as 1m 0s', () => {
+    expect(formatDurationMmSs(60)).toBe('1m 0s');
+  });
+
+  it('formats 61 seconds as 1m 1s', () => {
+    expect(formatDurationMmSs(61)).toBe('1m 1s');
+  });
+
+  it('formats single digit seconds without leading zero', () => {
+    expect(formatDurationMmSs(5)).toBe('5s');
+  });
+
+  it('formats minutes and seconds correctly', () => {
+    expect(formatDurationMmSs(125)).toBe('2m 5s');
+  });
+
+  it('formats large durations correctly', () => {
+    // 10 minutes 30 seconds = 630 seconds
+    expect(formatDurationMmSs(630)).toBe('10m 30s');
+  });
+
+  it('formats hour+ durations correctly', () => {
+    // 1 hour 5 minutes = 65 minutes = 3900 seconds
+    expect(formatDurationMmSs(3900)).toBe('65m 0s');
+  });
+
+  describe('input validation', () => {
+    it('returns 0s for negative values', () => {
+      expect(formatDurationMmSs(-1)).toBe('0s');
+      expect(formatDurationMmSs(-60)).toBe('0s');
+      expect(formatDurationMmSs(-100)).toBe('0s');
+    });
+
+    it('returns 0s for NaN', () => {
+      expect(formatDurationMmSs(NaN)).toBe('0s');
+    });
+
+    it('returns 0s for Infinity', () => {
+      expect(formatDurationMmSs(Infinity)).toBe('0s');
+      expect(formatDurationMmSs(-Infinity)).toBe('0s');
+    });
+  });
+});