@mseep/claudian 2.0.25

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

@@ -0,0 +1,407 @@
+import type { App, TFile } from 'obsidian';
+
+import { replaceImageEmbedsWithHtml } from '@/utils/imageEmbed';
+
+type LinkResolver = (
+  linkPath: string,
+  sourcePath: string,
+  files: Map<string, TFile>
+) => TFile | null | undefined;
+
+// Mock App and vault for testing
+function createMockApp(files: Map<string, string> = new Map(), resolveLink?: LinkResolver): App {
+  const mockFiles = new Map<string, TFile>();
+  files.forEach((resourcePath, filePath) => {
+    mockFiles.set(filePath, {
+      path: filePath,
+      basename: filePath.split('/').pop()?.replace(/\.[^.]+$/, '') || filePath,
+    } as TFile);
+  });
+
+  return {
+    vault: {
+      getAbstractFileByPath: (path: string) => mockFiles.get(path) || null,
+      getResourcePath: (file: TFile) => files.get(file.path) || `app://local/${file.path}`,
+    },
+    metadataCache: {
+      getFirstLinkpathDest: (linkPath: string, sourcePath: string) => {
+        const resolved = resolveLink?.(linkPath, sourcePath, mockFiles);
+        if (resolved !== undefined) {
+          return resolved;
+        }
+
+        // Try to find by basename
+        for (const [path, file] of mockFiles) {
+          if (path.endsWith(linkPath) || path === linkPath) {
+            return file;
+          }
+        }
+        return null;
+      },
+    },
+  } as unknown as App;
+}
+
+describe('replaceImageEmbedsWithHtml', () => {
+  describe('basic image embeds', () => {
+    it('replaces simple image embed with img tag', () => {
+      const app = createMockApp(new Map([['image.png', 'app://local/image.png']]));
+      const result = replaceImageEmbedsWithHtml('![[image.png]]', app);
+
+      expect(result).toContain('<img');
+      expect(result).toContain('src="app://local/image.png"');
+      expect(result).toContain('class="claudian-embedded-image"');
+    });
+
+    it('replaces image embed with folder path', () => {
+      const app = createMockApp(new Map([['assets/photo.jpg', 'app://local/assets/photo.jpg']]));
+      const result = replaceImageEmbedsWithHtml('![[assets/photo.jpg]]', app);
+
+      expect(result).toContain('src="app://local/assets/photo.jpg"');
+    });
+
+    it('handles image in surrounding text', () => {
+      const app = createMockApp(new Map([['test.png', 'app://local/test.png']]));
+      const result = replaceImageEmbedsWithHtml('Check this ![[test.png]] image', app);
+
+      expect(result).toContain('Check this');
+      expect(result).toContain('image');
+      expect(result).toContain('<img');
+    });
+  });
+
+  describe('alt text and dimensions', () => {
+    it('uses alt text from wikilink', () => {
+      const app = createMockApp(new Map([['image.png', 'app://local/image.png']]));
+      const result = replaceImageEmbedsWithHtml('![[image.png|My Alt Text]]', app);
+
+      expect(result).toContain('alt="My Alt Text"');
+    });
+
+    it('applies width dimension from alt text', () => {
+      const app = createMockApp(new Map([['image.png', 'app://local/image.png']]));
+      const result = replaceImageEmbedsWithHtml('![[image.png|300]]', app);
+
+      expect(result).toContain('style="width: 300px;"');
+    });
+
+    it('applies width and height dimensions', () => {
+      const app = createMockApp(new Map([['image.png', 'app://local/image.png']]));
+      const result = replaceImageEmbedsWithHtml('![[image.png|200x150]]', app);
+
+      expect(result).toContain('style="width: 200px; height: 150px;"');
+    });
+
+    it('uses basename as alt when no alt text provided', () => {
+      const app = createMockApp(new Map([['folder/my-image.png', 'app://local/folder/my-image.png']]));
+      const result = replaceImageEmbedsWithHtml('![[folder/my-image.png]]', app);
+
+      expect(result).toContain('alt="my-image"');
+    });
+  });
+
+  describe('supported image extensions', () => {
+    const extensions = ['png', 'jpg', 'jpeg', 'gif', 'webp', 'svg', 'bmp', 'ico'];
+
+    extensions.forEach((ext) => {
+      it(`replaces .${ext} image embed`, () => {
+        const app = createMockApp(new Map([[`image.${ext}`, `app://local/image.${ext}`]]));
+        const result = replaceImageEmbedsWithHtml(`![[image.${ext}]]`, app);
+
+        expect(result).toContain('<img');
+        expect(result).toContain(`src="app://local/image.${ext}"`);
+      });
+    });
+
+    it('handles uppercase extensions (case-insensitive)', () => {
+      const app = createMockApp(new Map([['photo.PNG', 'app://local/photo.PNG']]));
+      const result = replaceImageEmbedsWithHtml('![[photo.PNG]]', app);
+
+      expect(result).toContain('<img');
+    });
+
+    it('handles mixed case extensions', () => {
+      const app = createMockApp(new Map([['image.JpG', 'app://local/image.JpG']]));
+      const result = replaceImageEmbedsWithHtml('![[image.JpG]]', app);
+
+      expect(result).toContain('<img');
+    });
+  });
+
+  describe('non-image embeds (should pass through)', () => {
+    it('leaves markdown file embed unchanged', () => {
+      const app = createMockApp();
+      const result = replaceImageEmbedsWithHtml('![[note.md]]', app);
+
+      expect(result).toBe('![[note.md]]');
+    });
+
+    it('leaves pdf embed unchanged', () => {
+      const app = createMockApp();
+      const result = replaceImageEmbedsWithHtml('![[document.pdf]]', app);
+
+      expect(result).toBe('![[document.pdf]]');
+    });
+
+    it('leaves audio embed unchanged', () => {
+      const app = createMockApp();
+      const result = replaceImageEmbedsWithHtml('![[audio.mp3]]', app);
+
+      expect(result).toBe('![[audio.mp3]]');
+    });
+
+    it('processes only image embeds in mixed content', () => {
+      const app = createMockApp(new Map([['image.png', 'app://local/image.png']]));
+      const result = replaceImageEmbedsWithHtml('![[note.md]] and ![[image.png]]', app);
+
+      expect(result).toContain('![[note.md]]');
+      expect(result).toContain('<img');
+    });
+  });
+
+  describe('file not found (fallback)', () => {
+    it('shows fallback when image file not found', () => {
+      const app = createMockApp(); // Empty vault
+      const result = replaceImageEmbedsWithHtml('![[missing.png]]', app);
+
+      expect(result).toContain('class="claudian-embedded-image-fallback"');
+      expect(result).toContain('![[missing.png]]');
+    });
+
+    it('escapes HTML in fallback wikilink', () => {
+      const app = createMockApp();
+      const result = replaceImageEmbedsWithHtml('![[<script>alert(1)</script>.png]]', app);
+
+      expect(result).not.toContain('<script>');
+      expect(result).toContain('&lt;script&gt;');
+    });
+  });
+
+  describe('media folder resolution', () => {
+    it('resolves image from media folder', () => {
+      const app = createMockApp(new Map([['attachments/photo.png', 'app://local/attachments/photo.png']]));
+      const result = replaceImageEmbedsWithHtml('![[photo.png]]', app, 'attachments');
+
+      expect(result).toContain('src="app://local/attachments/photo.png"');
+    });
+
+    it('prefers direct path over media folder', () => {
+      const app = createMockApp(
+        new Map([
+          ['image.png', 'app://local/image.png'],
+          ['attachments/image.png', 'app://local/attachments/image.png'],
+        ])
+      );
+      const result = replaceImageEmbedsWithHtml('![[image.png]]', app, 'attachments');
+
+      expect(result).toContain('src="app://local/image.png"');
+    });
+  });
+
+  describe('source path resolution', () => {
+    it('passes source path into Obsidian link resolution for ambiguous image embeds', () => {
+      const app = createMockApp(
+        new Map([
+          ['section-a/image.png', 'app://local/section-a/image.png'],
+          ['section-b/image.png', 'app://local/section-b/image.png'],
+        ]),
+        (linkPath, sourcePath, files) => {
+          if (linkPath === 'image.png' && sourcePath === 'section-b/note.md') {
+            return files.get('section-b/image.png');
+          }
+          return files.get('section-a/image.png');
+        }
+      );
+
+      const result = replaceImageEmbedsWithHtml('![[image.png]]', app, {
+        sourcePath: 'section-b/note.md',
+      });
+
+      expect(result).toContain('src="app://local/section-b/image.png"');
+      expect(result).not.toContain('section-a/image.png');
+    });
+  });
+
+  describe('multiple image embeds', () => {
+    it('replaces multiple images in text', () => {
+      const app = createMockApp(
+        new Map([
+          ['a.png', 'app://local/a.png'],
+          ['b.png', 'app://local/b.png'],
+        ])
+      );
+      const result = replaceImageEmbedsWithHtml('![[a.png]] and ![[b.png]]', app);
+
+      expect(result).toContain('src="app://local/a.png"');
+      expect(result).toContain('src="app://local/b.png"');
+    });
+
+    it('replaces consecutive image embeds', () => {
+      const app = createMockApp(
+        new Map([
+          ['1.png', 'app://local/1.png'],
+          ['2.png', 'app://local/2.png'],
+        ])
+      );
+      const result = replaceImageEmbedsWithHtml('![[1.png]]![[2.png]]', app);
+
+      expect((result.match(/<img/g) || []).length).toBe(2);
+    });
+  });
+
+  describe('HTML escaping (security)', () => {
+    it('escapes HTML in image src', () => {
+      const app = createMockApp(new Map([['test.png', 'app://local/path"><script>alert(1)</script>']]));
+      const result = replaceImageEmbedsWithHtml('![[test.png]]', app);
+
+      expect(result).not.toContain('<script>');
+      expect(result).toContain('&lt;script&gt;');
+    });
+
+    it('escapes HTML in alt text', () => {
+      const app = createMockApp(new Map([['test.png', 'app://local/test.png']]));
+      const result = replaceImageEmbedsWithHtml('![[test.png|<b>bold</b>]]', app);
+
+      expect(result).not.toContain('<b>');
+      expect(result).toContain('&lt;b&gt;');
+    });
+  });
+
+  describe('edge cases', () => {
+    it('handles empty string', () => {
+      const app = createMockApp();
+      const result = replaceImageEmbedsWithHtml('', app);
+
+      expect(result).toBe('');
+    });
+
+    it('handles text without embeds', () => {
+      const app = createMockApp();
+      const result = replaceImageEmbedsWithHtml('Just plain text', app);
+
+      expect(result).toBe('Just plain text');
+    });
+
+    it('handles incomplete embed syntax', () => {
+      const app = createMockApp();
+      const result = replaceImageEmbedsWithHtml('![[incomplete', app);
+
+      expect(result).toBe('![[incomplete');
+    });
+
+    it('handles multiple sequential calls (regex lastIndex reset)', () => {
+      const app = createMockApp(new Map([['a.png', 'app://local/a.png']]));
+
+      // First call
+      const result1 = replaceImageEmbedsWithHtml('![[a.png]]', app);
+      // Second call - would fail without lastIndex reset
+      const result2 = replaceImageEmbedsWithHtml('![[a.png]]', app);
+
+      expect(result1).toContain('<img');
+      expect(result2).toContain('<img');
+    });
+
+    it('replaces image embeds in multiline content', () => {
+      const app = createMockApp(new Map([['test.png', 'app://local/test.png']]));
+      const result = replaceImageEmbedsWithHtml(
+        'First paragraph\n\n![[test.png]]\n\nThird paragraph',
+        app
+      );
+
+      expect(result).toContain('<img');
+      expect(result).toContain('First paragraph');
+      expect(result).toContain('Third paragraph');
+    });
+
+    it('handles special characters in filename', () => {
+      const filename = 'photo (2024-01-01).png';
+      const app = createMockApp(new Map([[filename, `app://local/${filename}`]]));
+      const result = replaceImageEmbedsWithHtml(`![[${filename}]]`, app);
+
+      expect(result).toContain('<img');
+    });
+
+    it('handles spaces in filename', () => {
+      const filename = 'my long image name.png';
+      const app = createMockApp(new Map([[filename, `app://local/${filename}`]]));
+      const result = replaceImageEmbedsWithHtml(`![[${filename}]]`, app);
+
+      expect(result).toContain('<img');
+    });
+
+    it('handles deep folder paths', () => {
+      const path = 'a/b/c/d/image.png';
+      const app = createMockApp(new Map([[path, `app://local/${path}`]]));
+      const result = replaceImageEmbedsWithHtml(`![[${path}]]`, app);
+
+      expect(result).toContain('<img');
+    });
+
+    it('includes lazy loading attribute', () => {
+      const app = createMockApp(new Map([['test.png', 'app://local/test.png']]));
+      const result = replaceImageEmbedsWithHtml('![[test.png]]', app);
+
+      expect(result).toContain('loading="lazy"');
+    });
+  });
+
+  describe('error handling', () => {
+    it('returns unchanged markdown when app is not initialized', () => {
+      // @ts-expect-error - testing invalid input
+      const result = replaceImageEmbedsWithHtml('![[image.png]]', null);
+
+      expect(result).toBe('![[image.png]]');
+    });
+
+    it('returns unchanged markdown when vault is missing', () => {
+      const app = { metadataCache: {} } as unknown as App;
+      const result = replaceImageEmbedsWithHtml('![[image.png]]', app);
+
+      expect(result).toBe('![[image.png]]');
+    });
+
+    it('returns unchanged markdown when metadataCache is missing', () => {
+      const app = { vault: {} } as unknown as App;
+      const result = replaceImageEmbedsWithHtml('![[image.png]]', app);
+
+      expect(result).toBe('![[image.png]]');
+    });
+
+    it('returns fallback when getResourcePath throws', () => {
+      const mockFile = { path: 'test.png', basename: 'test' } as TFile;
+      const app = {
+        vault: {
+          getAbstractFileByPath: () => mockFile,
+          getResourcePath: () => {
+            throw new Error('Resource path failed');
+          },
+        },
+        metadataCache: {
+          getFirstLinkpathDest: () => null,
+        },
+      } as unknown as App;
+
+      const result = replaceImageEmbedsWithHtml('![[test.png]]', app);
+
+      expect(result).toContain('class="claudian-embedded-image-fallback"');
+    });
+  });
+
+  describe('regular wikilinks (should NOT match)', () => {
+    it('does not replace regular wikilink', () => {
+      const app = createMockApp();
+      const result = replaceImageEmbedsWithHtml('[[note.md]]', app);
+
+      expect(result).toBe('[[note.md]]');
+      expect(result).not.toContain('<img');
+    });
+
+    it('processes image embed but not file link', () => {
+      const app = createMockApp(new Map([['image.png', 'app://local/image.png']]));
+      const result = replaceImageEmbedsWithHtml('[[note.md]] and ![[image.png]]', app);
+
+      expect(result).toContain('[[note.md]]');
+      expect(result).toContain('<img');
+    });
+  });
+});

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

@@ -0,0 +1,63 @@
+import { escapeHtml, normalizeInsertionText } from '@/utils/inlineEdit';
+
+describe('normalizeInsertionText', () => {
+  it('removes leading blank lines', () => {
+    expect(normalizeInsertionText('\n\nHello')).toBe('Hello');
+  });
+
+  it('removes trailing blank lines', () => {
+    expect(normalizeInsertionText('Hello\n\n')).toBe('Hello');
+  });
+
+  it('removes both leading and trailing blank lines', () => {
+    expect(normalizeInsertionText('\n\nHello\n\n')).toBe('Hello');
+  });
+
+  it('handles \\r\\n line endings', () => {
+    expect(normalizeInsertionText('\r\n\r\nHello\r\n\r\n')).toBe('Hello');
+  });
+
+  it('preserves internal newlines', () => {
+    expect(normalizeInsertionText('\nLine 1\nLine 2\n')).toBe('Line 1\nLine 2');
+  });
+
+  it('returns empty string unchanged', () => {
+    expect(normalizeInsertionText('')).toBe('');
+  });
+
+  it('returns text unchanged when no leading/trailing newlines', () => {
+    expect(normalizeInsertionText('Hello World')).toBe('Hello World');
+  });
+});
+
+describe('escapeHtml', () => {
+  it('escapes < to &lt;', () => {
+    expect(escapeHtml('<div>')).toBe('&lt;div&gt;');
+  });
+
+  it('escapes > to &gt;', () => {
+    expect(escapeHtml('a > b')).toBe('a &gt; b');
+  });
+
+  it('escapes & to &amp;', () => {
+    expect(escapeHtml('a & b')).toBe('a &amp; b');
+  });
+
+  it('escapes " to &quot;', () => {
+    expect(escapeHtml('a "b" c')).toBe('a &quot;b&quot; c');
+  });
+
+  it('escapes all special characters together', () => {
+    expect(escapeHtml('<script>alert("x&y")</script>')).toBe(
+      '&lt;script&gt;alert(&quot;x&amp;y&quot;)&lt;/script&gt;'
+    );
+  });
+
+  it('returns text unchanged when no special characters', () => {
+    expect(escapeHtml('Hello World')).toBe('Hello World');
+  });
+
+  it('handles empty string', () => {
+    expect(escapeHtml('')).toBe('');
+  });
+});

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

@@ -0,0 +1,73 @@
+import {
+  isBracketInterruptText,
+  isCompactionCanceledStderr,
+  isInterruptSignalText,
+} from '@/utils/interrupt';
+
+describe('interrupt utils', () => {
+  describe('isBracketInterruptText', () => {
+    it('matches canonical SDK interrupt markers', () => {
+      expect(isBracketInterruptText('[Request interrupted by user]')).toBe(true);
+      expect(isBracketInterruptText('[Request interrupted by user for tool use]')).toBe(true);
+    });
+
+    it('matches canonical markers with surrounding whitespace', () => {
+      expect(isBracketInterruptText('  [Request interrupted by user]  ')).toBe(true);
+      expect(isBracketInterruptText('\n[Request interrupted by user for tool use]\n')).toBe(true);
+    });
+
+    it('rejects partial and prefixed variants', () => {
+      expect(isBracketInterruptText('[Request interrupted by user] extra')).toBe(false);
+      expect(isBracketInterruptText('prefix [Request interrupted by user]')).toBe(false);
+      expect(isBracketInterruptText('[Request interrupted]')).toBe(false);
+    });
+  });
+
+  describe('isCompactionCanceledStderr', () => {
+    it('matches canonical compaction stderr marker', () => {
+      expect(
+        isCompactionCanceledStderr(
+          '<local-command-stderr>Error: Compaction canceled.</local-command-stderr>',
+        ),
+      ).toBe(true);
+    });
+
+    it('accepts whitespace around canonical compaction stderr marker', () => {
+      expect(
+        isCompactionCanceledStderr(
+          '\n<local-command-stderr> Error: Compaction canceled. </local-command-stderr>\n',
+        ),
+      ).toBe(true);
+    });
+
+    it('rejects embedded mentions and non-canonical wrappers', () => {
+      expect(
+        isCompactionCanceledStderr(
+          '## Context\\n<local-command-stderr>Error: Compaction canceled.</local-command-stderr>',
+        ),
+      ).toBe(false);
+      expect(
+        isCompactionCanceledStderr(
+          '<task-notification><result><local-command-stderr>Error: Compaction canceled.</local-command-stderr></result></task-notification>',
+        ),
+      ).toBe(false);
+    });
+  });
+
+  describe('isInterruptSignalText', () => {
+    it('matches all supported interrupt markers', () => {
+      expect(isInterruptSignalText('[Request interrupted by user]')).toBe(true);
+      expect(isInterruptSignalText('[Request interrupted by user for tool use]')).toBe(true);
+      expect(
+        isInterruptSignalText(
+          '<local-command-stderr>Error: Compaction canceled.</local-command-stderr>',
+        ),
+      ).toBe(true);
+    });
+
+    it('rejects regular content', () => {
+      expect(isInterruptSignalText('Hello')).toBe(false);
+      expect(isInterruptSignalText('<local-command-stderr>Error: Timeout.</local-command-stderr>')).toBe(false);
+    });
+  });
+});

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

@@ -0,0 +1,35 @@
+import { appendMarkdownSnippet } from '@/utils/markdown';
+
+describe('appendMarkdownSnippet', () => {
+  it('returns existing prompt when snippet is empty', () => {
+    expect(appendMarkdownSnippet('Hello', '')).toBe('Hello');
+  });
+
+  it('returns existing prompt when snippet is whitespace only', () => {
+    expect(appendMarkdownSnippet('Hello', '   \n  ')).toBe('Hello');
+  });
+
+  it('returns trimmed snippet when existing prompt is empty', () => {
+    expect(appendMarkdownSnippet('', '  Hello  ')).toBe('Hello');
+  });
+
+  it('returns trimmed snippet when existing prompt is whitespace only', () => {
+    expect(appendMarkdownSnippet('   ', '  Hello  ')).toBe('Hello');
+  });
+
+  it('adds double newline separator when prompt does not end with newline', () => {
+    expect(appendMarkdownSnippet('First', 'Second')).toBe('First\n\nSecond');
+  });
+
+  it('adds single newline when prompt ends with one newline', () => {
+    expect(appendMarkdownSnippet('First\n', 'Second')).toBe('First\n\nSecond');
+  });
+
+  it('adds no separator when prompt ends with double newline', () => {
+    expect(appendMarkdownSnippet('First\n\n', 'Second')).toBe('First\n\nSecond');
+  });
+
+  it('trims the snippet before appending', () => {
+    expect(appendMarkdownSnippet('First', '  Second  ')).toBe('First\n\nSecond');
+  });
+});

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

@@ -0,0 +1,54 @@
+import {
+  escapeMathDelimitersForStreaming,
+  hasStreamingMathDelimiters,
+} from '@/utils/markdownMath';
+
+describe('markdownMath', () => {
+  describe('escapeMathDelimitersForStreaming', () => {
+    it('escapes inline and display math delimiters outside code', () => {
+      expect(escapeMathDelimitersForStreaming('Use $x + y$ and $$z^2$$.')).toBe(
+        'Use \\$x + y\\$ and \\$\\$z^2\\$\\$.'
+      );
+    });
+
+    it('preserves inline code and fenced code dollars', () => {
+      const markdown = [
+        'Text $x$',
+        '`echo $PATH`',
+        '```bash',
+        'echo "$HOME"',
+        '```',
+        'Done $$y$$',
+      ].join('\n');
+
+      expect(escapeMathDelimitersForStreaming(markdown)).toBe([
+        'Text \\$x\\$',
+        '`echo $PATH`',
+        '```bash',
+        'echo "$HOME"',
+        '```',
+        'Done \\$\\$y\\$\\$',
+      ].join('\n'));
+    });
+
+    it('keeps already escaped dollars unchanged', () => {
+      expect(escapeMathDelimitersForStreaming('Cost is \\$5, math is $x$.')).toBe(
+        'Cost is \\$5, math is \\$x\\$.'
+      );
+    });
+
+    it('does not alter dollars inside raw html tag attributes', () => {
+      expect(escapeMathDelimitersForStreaming('<span title="$x$">value $y$</span>')).toBe(
+        '<span title="$x$">value \\$y\\$</span>'
+      );
+    });
+  });
+
+  describe('hasStreamingMathDelimiters', () => {
+    it('detects unescaped dollars outside code', () => {
+      expect(hasStreamingMathDelimiters('math $x$')).toBe(true);
+      expect(hasStreamingMathDelimiters('`echo $PATH`')).toBe(false);
+      expect(hasStreamingMathDelimiters('\\$5')).toBe(false);
+    });
+  });
+});