@mseep/claudian 2.0.25

package/src/utils/imageEmbed.ts

@@ -0,0 +1,139 @@
+/**
+ * Claudian - Image Embed Utilities
+ *
+ * Replaces Obsidian image embeds ![[image.png]] with HTML <img> tags
+ * before MarkdownRenderer processes the content.
+ *
+ * Note: This is display-only - the agent still receives the wikilink text.
+ */
+
+import type { App, TFile } from 'obsidian';
+
+import { escapeHtml } from './inlineEdit';
+import { getVaultFileByPath } from './obsidianCompat';
+
+const IMAGE_EXTENSIONS = new Set([
+  'png',
+  'jpg',
+  'jpeg',
+  'gif',
+  'webp',
+  'svg',
+  'bmp',
+  'ico',
+]);
+
+const IMAGE_EMBED_PATTERN = /!\[\[([^\]|]+)(?:\|([^\]]+))?\]\]/g;
+
+interface ReplaceImageEmbedsOptions {
+  mediaFolder?: string;
+  sourcePath?: string;
+}
+
+function isImagePath(path: string): boolean {
+  const ext = path.split('.').pop()?.toLowerCase();
+  return ext ? IMAGE_EXTENSIONS.has(ext) : false;
+}
+
+function resolveImageFile(
+  app: App,
+  imagePath: string,
+  options: Required<ReplaceImageEmbedsOptions>
+): TFile | null {
+  let file = getVaultFileByPath(app, imagePath);
+  if (file) return file;
+
+  if (options.mediaFolder) {
+    const withFolder = `${options.mediaFolder}/${imagePath}`;
+    file = getVaultFileByPath(app, withFolder);
+    if (file) return file;
+  }
+
+  const resolved = app.metadataCache.getFirstLinkpathDest(imagePath, options.sourcePath);
+  if (resolved) return resolved;
+
+  return null;
+}
+
+
+/** Supports formats: "100" (width only) or "100x200" (width x height) */
+function buildStyleAttribute(altText: string | undefined): string {
+  if (!altText) return '';
+
+  const dimMatch = altText.match(/^(\d+)(?:x(\d+))?$/);
+  if (!dimMatch) return '';
+
+  const width = dimMatch[1];
+  const height = dimMatch[2];
+
+  if (height) {
+    return ` style="width: ${width}px; height: ${height}px;"`;
+  }
+  return ` style="width: ${width}px;"`;
+}
+
+function createImageHtml(
+  app: App,
+  file: TFile,
+  altText: string | undefined
+): string {
+  const src = app.vault.getResourcePath(file);
+  const alt = escapeHtml(altText || file.basename);
+  const style = buildStyleAttribute(altText);
+
+  return `<span class="claudian-embedded-image"><img src="${escapeHtml(src)}" alt="${alt}" loading="lazy"${style}></span>`;
+}
+
+function createFallbackHtml(wikilink: string): string {
+  return `<span class="claudian-embedded-image-fallback">${escapeHtml(wikilink)}</span>`;
+}
+
+function normalizeOptions(options?: string | ReplaceImageEmbedsOptions): Required<ReplaceImageEmbedsOptions> {
+  if (typeof options === 'string') {
+    return { mediaFolder: options, sourcePath: '' };
+  }
+
+  return {
+    mediaFolder: options?.mediaFolder ?? '',
+    sourcePath: options?.sourcePath ?? '',
+  };
+}
+
+/**
+ * Call before MarkdownRenderer.render().
+ * Non-image embeds (e.g., ![[note.md]]) pass through unchanged.
+ */
+export function replaceImageEmbedsWithHtml(
+  markdown: string,
+  app: App,
+  options?: string | ReplaceImageEmbedsOptions
+): string {
+  if (!app?.vault || !app?.metadataCache) {
+    return markdown;
+  }
+
+  const normalizedOptions = normalizeOptions(options);
+
+  // Reset lastIndex to avoid issues with global regex
+  IMAGE_EMBED_PATTERN.lastIndex = 0;
+
+  return markdown.replace(
+    IMAGE_EMBED_PATTERN,
+    (match, imagePath: string, altText: string | undefined) => {
+      try {
+        if (!isImagePath(imagePath)) {
+          return match;
+        }
+
+        const file = resolveImageFile(app, imagePath, normalizedOptions);
+        if (!file) {
+          return createFallbackHtml(match);
+        }
+
+        return createImageHtml(app, file, altText);
+      } catch {
+        return createFallbackHtml(match);
+      }
+    }
+  );
+}

package/src/utils/inlineEdit.ts

@@ -0,0 +1,22 @@
+/**
+ * Utilities for inline edit UI.
+ * Kept dependency-free so tests can import directly.
+ */
+
+/**
+ * Trims leading and trailing blank lines from insertion text.
+ * Matches the behavior expected by cursor insertion preview.
+ */
+export function normalizeInsertionText(text: string): string {
+  return text.replace(/^(?:\r?\n)+|(?:\r?\n)+$/g, '');
+}
+
+/** Escapes HTML special characters to prevent injection in rendered content. */
+export function escapeHtml(text: string): string {
+  return text
+    .replace(/&/g, '&')
+    .replace(/</g, '&lt;')
+    .replace(/>/g, '&gt;')
+    .replace(/"/g, '&quot;');
+}
+

package/src/utils/interrupt.ts

@@ -0,0 +1,23 @@
+const INTERRUPT_MARKERS = new Set([
+  '[Request interrupted by user]',
+  '[Request interrupted by user for tool use]',
+]);
+
+const COMPACTION_CANCELED_STDERR_PATTERN =
+  /^<local-command-stderr>\s*Error:\s*Compaction canceled\.?\s*<\/local-command-stderr>$/i;
+
+function normalize(text: string): string {
+  return text.trim();
+}
+
+export function isBracketInterruptText(text: string): boolean {
+  return INTERRUPT_MARKERS.has(normalize(text));
+}
+
+export function isCompactionCanceledStderr(text: string): boolean {
+  return COMPACTION_CANCELED_STDERR_PATTERN.test(normalize(text));
+}
+
+export function isInterruptSignalText(text: string): boolean {
+  return isBracketInterruptText(text) || isCompactionCanceledStderr(text);
+}

package/src/utils/markdown.ts

@@ -0,0 +1,25 @@
+/**
+ * Claudian - Markdown Utilities
+ *
+ * Markdown manipulation helpers.
+ */
+
+/** Appends a Markdown snippet to an existing prompt with sensible spacing. */
+export function appendMarkdownSnippet(existingPrompt: string, snippet: string): string {
+  const trimmedSnippet = snippet.trim();
+  if (!trimmedSnippet) {
+    return existingPrompt;
+  }
+
+  if (!existingPrompt.trim()) {
+    return trimmedSnippet;
+  }
+
+  const separator = existingPrompt.endsWith('\n\n')
+    ? ''
+    : existingPrompt.endsWith('\n')
+      ? '\n'
+      : '\n\n';
+
+  return existingPrompt + separator + trimmedSnippet;
+}

package/src/utils/markdownMath.ts

@@ -0,0 +1,130 @@
+interface FenceState {
+  marker: '`' | '~';
+  length: number;
+}
+
+function getFenceRun(line: string): string | null {
+  const match = line.match(/^ {0,3}(`{3,}|~{3,})/);
+  return match?.[1] ?? null;
+}
+
+function isClosingFence(line: string, fence: FenceState): boolean {
+  const run = getFenceRun(line);
+  return !!run && run[0] === fence.marker && run.length >= fence.length;
+}
+
+function isHtmlTagStart(line: string, index: number): boolean {
+  const next = line[index + 1];
+  return !!next && /[A-Za-z/!?]/.test(next);
+}
+
+function readBacktickRun(line: string, index: number): number {
+  let length = 0;
+  while (line[index + length] === '`') {
+    length += 1;
+  }
+  return length;
+}
+
+function escapeMathDelimitersInLine(line: string): string {
+  let escaped = '';
+  let inlineCodeRunLength = 0;
+  let inHtmlTag = false;
+
+  for (let index = 0; index < line.length; index += 1) {
+    const char = line[index];
+
+    if (char === '`') {
+      const runLength = readBacktickRun(line, index);
+      escaped += line.slice(index, index + runLength);
+      index += runLength - 1;
+      if (inlineCodeRunLength === 0) {
+        inlineCodeRunLength = runLength;
+      } else if (runLength === inlineCodeRunLength) {
+        inlineCodeRunLength = 0;
+      }
+      continue;
+    }
+
+    if (inlineCodeRunLength > 0) {
+      escaped += char;
+      continue;
+    }
+
+    if (inHtmlTag) {
+      escaped += char;
+      if (char === '>') {
+        inHtmlTag = false;
+      }
+      continue;
+    }
+
+    if (char === '<' && isHtmlTagStart(line, index)) {
+      inHtmlTag = true;
+      escaped += char;
+      continue;
+    }
+
+    if (char === '\\' && line[index + 1] === '$') {
+      escaped += '\\$';
+      index += 1;
+      continue;
+    }
+
+    escaped += char === '$' ? '\\$' : char;
+  }
+
+  return escaped;
+}
+
+/**
+ * Escapes dollar math delimiters outside code spans and fenced code blocks.
+ * Used only for transient streaming renders so MarkdownRenderer does not hand
+ * incomplete math to Obsidian's math renderer on every frame.
+ */
+export function escapeMathDelimitersForStreaming(markdown: string): string {
+  if (!markdown.includes('$')) {
+    return markdown;
+  }
+
+  let result = '';
+  let fence: FenceState | null = null;
+  let lineStart = 0;
+
+  while (lineStart < markdown.length) {
+    const newlineIndex = markdown.indexOf('\n', lineStart);
+    const lineEnd = newlineIndex === -1 ? markdown.length : newlineIndex + 1;
+    const line = markdown.slice(lineStart, lineEnd);
+    const lineWithoutNewline = line.endsWith('\n') ? line.slice(0, -1) : line;
+
+    if (fence) {
+      result += line;
+      if (isClosingFence(lineWithoutNewline, fence)) {
+        fence = null;
+      }
+    } else {
+      const fenceRun = getFenceRun(lineWithoutNewline);
+      if (fenceRun) {
+        result += line;
+        fence = {
+          marker: fenceRun[0] as '`' | '~',
+          length: fenceRun.length,
+        };
+      } else {
+        result += escapeMathDelimitersInLine(line);
+      }
+    }
+
+    lineStart = lineEnd;
+  }
+
+  return result;
+}
+
+export function hasStreamingMathDelimiters(markdown: string): boolean {
+  if (!markdown.includes('$')) {
+    return false;
+  }
+
+  return escapeMathDelimitersForStreaming(markdown) !== markdown;
+}

package/src/utils/mcp.ts

@@ -0,0 +1,96 @@
+export function extractMcpMentions(text: string, validNames: Set<string>): Set<string> {
+  const mentions = new Set<string>();
+  const regex = /@([a-zA-Z0-9._-]+)(?!\/)/g;
+  let match: RegExpExecArray | null;
+
+  while ((match = regex.exec(text)) !== null) {
+    const name = match[1];
+    if (validNames.has(name)) {
+      mentions.add(name);
+    }
+  }
+
+  return mentions;
+}
+
+/**
+ * Transform MCP mentions in text by appending " MCP" after each valid @mention.
+ * This is applied to the API request only, not shown in the input.
+ */
+export function transformMcpMentions(text: string, validNames: Set<string>): string {
+  if (validNames.size === 0) return text;
+
+  // Sort names by length (longest first) to avoid partial matches
+  const sortedNames = Array.from(validNames).sort((a, b) => b.length - a.length);
+
+  // Build single pattern with alternation (more efficient than N passes)
+  const escapedNames = sortedNames.map(escapeRegExp).join('|');
+  // Match @name that:
+  // - is not already followed by " MCP"
+  // - is not followed by "/" (context folder)
+  // - is not followed by alphanumeric/underscore/hyphen (partial match)
+  // - is not followed by "." + word char (e.g., @test in @test.server)
+  // This allows @server. (period as punctuation) while preventing @test.foo matches
+  const pattern = new RegExp(
+    `@(${escapedNames})(?! MCP)(?!/)(?![a-zA-Z0-9_-])(?!\\.[a-zA-Z0-9_-])`,
+    'g'
+  );
+
+  return text.replace(pattern, '@$1 MCP');
+}
+
+function escapeRegExp(str: string): string {
+  return str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+
+export function parseCommand(command: string, providedArgs?: string[]): { cmd: string; args: string[] } {
+  if (providedArgs && providedArgs.length > 0) {
+    return { cmd: command, args: providedArgs };
+  }
+
+  const parts = splitCommandString(command);
+  if (parts.length === 0) {
+    return { cmd: '', args: [] };
+  }
+
+  return { cmd: parts[0], args: parts.slice(1) };
+}
+
+export function splitCommandString(cmdStr: string): string[] {
+  const parts: string[] = [];
+  let current = '';
+  let inQuote = false;
+  let quoteChar = '';
+
+  for (let i = 0; i < cmdStr.length; i++) {
+    const char = cmdStr[i];
+
+    if ((char === '"' || char === "'") && !inQuote) {
+      inQuote = true;
+      quoteChar = char;
+      continue;
+    }
+
+    if (char === quoteChar && inQuote) {
+      inQuote = false;
+      quoteChar = '';
+      continue;
+    }
+
+    if (/\s/.test(char) && !inQuote) {
+      if (current) {
+        parts.push(current);
+        current = '';
+      }
+      continue;
+    }
+
+    current += char;
+  }
+
+  if (current) {
+    parts.push(current);
+  }
+
+  return parts;
+}

package/src/utils/obsidianCompat.ts

@@ -0,0 +1,23 @@
+import type { App, TFile, Workspace, WorkspaceLeaf } from 'obsidian';
+
+export function getVaultFileByPath(app: App, filePath: string): TFile | null {
+  const file = app.vault.getAbstractFileByPath(filePath);
+  if (isVaultFile(file)) {
+    return file;
+  }
+  return null;
+}
+
+export async function revealWorkspaceLeaf(workspace: Workspace, leaf: WorkspaceLeaf): Promise<void> {
+  await workspace.revealLeaf(leaf);
+}
+
+function isVaultFile(value: unknown): value is TFile {
+  if (!value || typeof value !== 'object') {
+    return false;
+  }
+
+  const candidate = value as Partial<TFile>;
+  return typeof candidate.path === 'string'
+    && typeof candidate.basename === 'string';
+}