@mseep/claudian 2.0.25

package/src/utils/externalContextScanner.ts

@@ -0,0 +1,135 @@
+/**
+ * Claudian - External Context Scanner
+ *
+ * Scans configured external context paths for files to include in @-mention dropdown.
+ * Features: recursive scanning, caching, and error handling.
+ */
+
+import * as fs from 'fs';
+import * as path from 'path';
+
+import { normalizePathForFilesystem } from './path';
+
+export interface ExternalContextFile {
+  path: string;
+  name: string;
+  relativePath: string;
+  contextRoot: string;
+  /** In milliseconds */
+  mtime: number;
+}
+
+interface ScanCache {
+  files: ExternalContextFile[];
+  timestamp: number;
+}
+
+const CACHE_TTL_MS = 30000;
+const MAX_FILES_PER_PATH = 1000;
+const MAX_DEPTH = 10;
+
+const SKIP_DIRECTORIES = new Set([
+  'node_modules',
+  '__pycache__',
+  'venv',
+  '.venv',
+  '.git',
+  '.svn',
+  '.hg',
+  'dist',
+  'build',
+  'out',
+  '.next',
+  '.nuxt',
+  'target',
+  'vendor',
+  'Pods',
+]);
+
+class ExternalContextScanner {
+  private cache = new Map<string, ScanCache>();
+
+  scanPaths(externalContextPaths: string[]): ExternalContextFile[] {
+    const allFiles: ExternalContextFile[] = [];
+    const now = Date.now();
+
+    for (const contextPath of externalContextPaths) {
+      const expandedPath = normalizePathForFilesystem(contextPath);
+
+      const cached = this.cache.get(expandedPath);
+      if (cached && now - cached.timestamp < CACHE_TTL_MS) {
+        allFiles.push(...cached.files);
+        continue;
+      }
+
+      const files = this.scanDirectory(expandedPath, expandedPath, 0);
+      this.cache.set(expandedPath, { files, timestamp: now });
+      allFiles.push(...files);
+    }
+
+    return allFiles;
+  }
+
+  private scanDirectory(
+    dir: string,
+    contextRoot: string,
+    depth: number
+  ): ExternalContextFile[] {
+    if (depth > MAX_DEPTH) return [];
+
+    const files: ExternalContextFile[] = [];
+
+    try {
+      if (!fs.existsSync(dir)) return [];
+
+      const stat = fs.statSync(dir);
+      if (!stat.isDirectory()) return [];
+
+      const entries = fs.readdirSync(dir, { withFileTypes: true });
+
+      for (const entry of entries) {
+        if (entry.name.startsWith('.')) continue;
+        if (SKIP_DIRECTORIES.has(entry.name)) continue;
+        // Symlinks can cause infinite recursion and directory escape
+        if (entry.isSymbolicLink()) continue;
+
+        const fullPath = path.join(dir, entry.name);
+
+        if (entry.isDirectory()) {
+          const subFiles = this.scanDirectory(fullPath, contextRoot, depth + 1);
+          files.push(...subFiles);
+        } else if (entry.isFile()) {
+          try {
+            const fileStat = fs.statSync(fullPath);
+            files.push({
+              path: fullPath,
+              name: entry.name,
+              relativePath: path.relative(contextRoot, fullPath),
+              contextRoot,
+              mtime: fileStat.mtimeMs,
+            });
+          } catch {
+            // Inaccessible file
+          }
+        }
+
+        if (files.length >= MAX_FILES_PER_PATH) break;
+      }
+    } catch {
+      // Inaccessible directory
+    }
+
+    return files;
+  }
+
+  invalidateCache(): void {
+    this.cache.clear();
+  }
+
+  invalidatePath(contextPath: string): void {
+    const expandedPath = normalizePathForFilesystem(contextPath);
+    this.cache.delete(expandedPath);
+  }
+}
+
+export const externalContextScanner = new ExternalContextScanner();

package/src/utils/fileLink.ts

@@ -0,0 +1,263 @@
+/**
+ * Claudian - File Link Utilities
+ *
+ * Detects Obsidian wikilinks [[path/to/file]] in rendered content and makes
+ * them clickable to open the file in Obsidian.
+ */
+
+import type { App, Component } from 'obsidian';
+
+import { getVaultFileByPath } from './obsidianCompat';
+
+/**
+ * Regex pattern to match Obsidian wikilinks in text content.
+ *
+ * Matches:
+ * - Standard wikilinks: [[note]] or [[folder/note]]
+ * - Wikilinks with display text: [[note|display text]]
+ * - Wikilinks with headings: [[note#heading]]
+ * - Wikilinks with block references: [[note^block]]
+ *
+ * Does NOT match image embeds ![[image.png]] (those are handled separately).
+ */
+const WIKILINK_PATTERN_SOURCE = '(?<!!)\\[\\[([^\\]|#^]+)(?:#[^\\]|]+)?(?:\\^[^\\]|]+)?(?:\\|[^\\]]+)?\\]\\]';
+
+/** Creates a fresh regex instance to avoid global state issues */
+function createWikilinkPattern(): RegExp {
+  return new RegExp(WIKILINK_PATTERN_SOURCE, 'g');
+}
+
+interface WikilinkMatch {
+  index: number;
+  fullMatch: string;
+  linkPath: string;
+  linkTarget: string;
+  displayText: string;
+}
+
+function buildWikilinkMatch(
+  fullMatch: string,
+  linkPath: string,
+  index: number
+): WikilinkMatch {
+  const pipeIndex = fullMatch.lastIndexOf('|');
+  const displayText = pipeIndex > 0 ? fullMatch.slice(pipeIndex + 1, -2) : linkPath;
+
+  return {
+    index,
+    fullMatch,
+    linkPath,
+    linkTarget: extractLinkTarget(fullMatch),
+    displayText,
+  };
+}
+
+export function extractLinkTarget(fullMatch: string): string {
+  const inner = fullMatch.slice(2, -2);
+  const pipeIndex = inner.indexOf('|');
+  return pipeIndex >= 0 ? inner.slice(0, pipeIndex) : inner;
+}
+
+/**
+ * Finds all wikilinks in text that exist in the vault.
+ * Sorted by index descending for end-to-start processing.
+ */
+function findWikilinks(app: App, text: string): WikilinkMatch[] {
+  const pattern = createWikilinkPattern();
+  const matches: WikilinkMatch[] = [];
+
+  let match: RegExpExecArray | null;
+  while ((match = pattern.exec(text)) !== null) {
+    const fullMatch = match[0];
+    const linkPath = match[1];
+
+    if (!fileExistsInVault(app, linkPath)) continue;
+
+    matches.push(buildWikilinkMatch(fullMatch, linkPath, match.index));
+  }
+
+  return matches.sort((a, b) => b.index - a.index);
+}
+
+function fileExistsInVault(app: App, linkPath: string): boolean {
+  const file = app.metadataCache.getFirstLinkpathDest(linkPath, '');
+  if (file) {
+    return true;
+  }
+
+  const directFile = getVaultFileByPath(app, linkPath);
+  if (directFile) {
+    return true;
+  }
+
+  if (!linkPath.endsWith('.md')) {
+    const withExt = getVaultFileByPath(app, linkPath + '.md');
+    if (withExt) {
+      return true;
+    }
+  }
+
+  return false;
+}
+
+function extractLinkPathFromTarget(linkTarget: string): string {
+  const subpathIndex = linkTarget.search(/[#^]/);
+  return subpathIndex >= 0 ? linkTarget.slice(0, subpathIndex) : linkTarget;
+}
+
+/**
+ * Creates a link element for a wikilink.
+ * Click handling is done via event delegation in registerFileLinkHandler.
+ */
+function createWikilink(
+  ownerDocument: Document,
+  linkTarget: string,
+  displayText: string
+): HTMLElement {
+  const link = ownerDocument.createElement('a');
+  link.className = 'claudian-file-link internal-link';
+  link.textContent = displayText;
+  link.setAttribute('data-href', linkTarget);
+  link.setAttribute('href', linkTarget);
+  return link;
+}
+
+function repairEmptyInternalLink(app: App, link: HTMLAnchorElement): void {
+  if ((link.textContent || '').trim()) return;
+
+  const linkTarget = link.dataset.href || link.getAttribute('data-href') || link.getAttribute('href');
+  if (!linkTarget) return;
+
+  const linkPath = extractLinkPathFromTarget(linkTarget);
+  if (!linkPath || !fileExistsInVault(app, linkPath)) return;
+
+  link.classList.add('claudian-file-link');
+  if (!link.dataset.href) {
+    link.setAttribute('data-href', linkTarget);
+  }
+  link.textContent = linkTarget;
+}
+
+/**
+ * Registers a delegated click handler for file links on a container.
+ * Should be called once on the messages container.
+ * Handles both our custom .claudian-file-link and Obsidian's .internal-link.
+ */
+export function registerFileLinkHandler(
+  app: App,
+  container: HTMLElement,
+  component: Component
+): void {
+  component.registerDomEvent(container, 'click', (event: MouseEvent) => {
+    const target = event.target as HTMLElement;
+    // Handle both our links and Obsidian's internal links
+    const link = target.closest('.claudian-file-link, .internal-link') as HTMLAnchorElement;
+
+    if (link) {
+      event.preventDefault();
+      const linkTarget = link.dataset.href || link.getAttribute('href');
+      if (linkTarget) {
+        void app.workspace.openLinkText(linkTarget, '', 'tab');
+      }
+    }
+  });
+}
+
+function buildFragmentWithLinks(ownerDocument: Document, text: string, matches: WikilinkMatch[]): DocumentFragment {
+  const fragment = ownerDocument.createDocumentFragment();
+  let currentIndex = text.length;
+
+  for (const { index, fullMatch, linkTarget, displayText } of matches) {
+    const endIndex = index + fullMatch.length;
+
+    if (endIndex < currentIndex) {
+      fragment.insertBefore(
+        ownerDocument.createTextNode(text.slice(endIndex, currentIndex)),
+        fragment.firstChild
+      );
+    }
+
+    fragment.insertBefore(createWikilink(ownerDocument, linkTarget, displayText), fragment.firstChild);
+    currentIndex = index;
+  }
+
+  if (currentIndex > 0) {
+    fragment.insertBefore(
+      ownerDocument.createTextNode(text.slice(0, currentIndex)),
+      fragment.firstChild
+    );
+  }
+
+  return fragment;
+}
+
+function processTextNode(app: App, node: Text): boolean {
+  const text = node.textContent;
+  if (!text || !text.includes('[[')) return false;
+
+  const matches = findWikilinks(app, text);
+  if (matches.length === 0) return false;
+
+  node.parentNode?.replaceChild(buildFragmentWithLinks(node.ownerDocument, text, matches), node);
+  return true;
+}
+
+/**
+ * Call after MarkdownRenderer.renderMarkdown().
+ * Catches wikilinks that remain as raw text after rendering, especially inline code spans.
+ */
+export function processFileLinks(app: App, container: HTMLElement): void {
+  if (!app || !container) return;
+
+  // Repair resolved internal links that rendered as empty anchors.
+  container.querySelectorAll('a.internal-link').forEach((linkEl) => {
+    repairEmptyInternalLink(app, linkEl as HTMLAnchorElement);
+  });
+
+  // Wikilinks in inline code aren't rendered by Obsidian's MarkdownRenderer
+  container.querySelectorAll('code').forEach((codeEl) => {
+    if (codeEl.parentElement?.tagName === 'PRE') return;
+
+    const text = codeEl.textContent;
+    if (!text || !text.includes('[[')) return;
+
+    const matches = findWikilinks(app, text);
+    if (matches.length === 0) return;
+
+    codeEl.textContent = '';
+    codeEl.appendChild(buildFragmentWithLinks(container.ownerDocument, text, matches));
+  });
+
+  const walker = container.ownerDocument.createTreeWalker(
+    container,
+    NodeFilter.SHOW_TEXT,
+    {
+      acceptNode(node) {
+        const parent = node.parentElement;
+        if (!parent) return NodeFilter.FILTER_REJECT;
+
+        const tagName = parent.tagName.toUpperCase();
+        if (tagName === 'PRE' || tagName === 'CODE' || tagName === 'A') {
+          return NodeFilter.FILTER_REJECT;
+        }
+
+        if (parent.closest('pre, code, a, .claudian-file-link, .internal-link')) {
+          return NodeFilter.FILTER_REJECT;
+        }
+
+        return NodeFilter.FILTER_ACCEPT;
+      },
+    }
+  );
+
+  // Modifying DOM while walking causes issues, so collect first
+  const textNodes: Text[] = [];
+  let node: Node | null;
+  while ((node = walker.nextNode())) {
+    textNodes.push(node as Text);
+  }
+
+  for (const textNode of textNodes) {
+    processTextNode(app, textNode);
+  }
+}

package/src/utils/frontmatter.ts

@@ -0,0 +1,194 @@
+import { parseYaml } from 'obsidian';
+
+const FRONTMATTER_PATTERN = /^---\r?\n([\s\S]*?)\r?\n---\r?\n?([\s\S]*)$/;
+const VALID_KEY_PATTERN = /^[\w-]+$/;
+
+function isValidKey(key: string): boolean {
+  return key.length > 0 && VALID_KEY_PATTERN.test(key);
+}
+
+function unquote(value: string): string {
+  if (
+    (value.startsWith('"') && value.endsWith('"')) ||
+    (value.startsWith("'") && value.endsWith("'"))
+  ) {
+    return value.slice(1, -1);
+  }
+  return value;
+}
+
+function parseScalarValue(rawValue: string): unknown {
+  const value = rawValue.trim();
+  if (value === 'true') return true;
+  if (value === 'false') return false;
+  if (value === 'null' || value === '') return null;
+  if (!Number.isNaN(Number(value))) return Number(value);
+  if (value.startsWith('[') && value.endsWith(']')) {
+    return value
+      .slice(1, -1)
+      .split(',')
+      .map(item => item.trim())
+      .filter(Boolean)
+      .map(item => unquote(item));
+  }
+  return unquote(value);
+}
+
+/** Handles malformed YAML (e.g. unquoted values with colons) by line-by-line key:value extraction. */
+function parseFrontmatterFallback(yamlContent: string): Record<string, unknown> {
+  const result: Record<string, unknown> = {};
+  const lines = yamlContent.split(/\r?\n/);
+  let currentListKey: string | null = null;
+  let currentList: unknown[] = [];
+
+  function flushList(): void {
+    if (!currentListKey) return;
+    result[currentListKey] = currentList;
+    currentListKey = null;
+    currentList = [];
+  }
+
+  let pendingBareKey: string | null = null;
+
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith('#')) continue;
+
+    if (currentListKey) {
+      if (trimmed.startsWith('- ')) {
+        currentList.push(parseScalarValue(trimmed.slice(2)));
+        continue;
+      }
+      flushList();
+    }
+
+    if (pendingBareKey) {
+      if (trimmed.startsWith('- ')) {
+        currentListKey = pendingBareKey;
+        currentList = [];
+        pendingBareKey = null;
+        currentList.push(parseScalarValue(trimmed.slice(2)));
+        continue;
+      }
+      result[pendingBareKey] = '';
+      pendingBareKey = null;
+    }
+
+    const colonIndex = trimmed.indexOf(': ');
+    if (colonIndex === -1) {
+      if (trimmed.endsWith(':')) {
+        const key = trimmed.slice(0, -1).trim();
+        if (isValidKey(key)) {
+          pendingBareKey = key;
+        }
+      }
+      continue;
+    }
+
+    const key = trimmed.slice(0, colonIndex).trim();
+    if (!isValidKey(key)) continue;
+    result[key] = parseScalarValue(trimmed.slice(colonIndex + 2));
+  }
+
+  if (pendingBareKey) {
+    result[pendingBareKey] = '';
+  }
+
+  flushList();
+  return result;
+}
+
+export function parseFrontmatter(
+  content: string
+): { frontmatter: Record<string, unknown>; body: string } | null {
+  const match = content.match(FRONTMATTER_PATTERN);
+  if (!match) return null;
+
+  try {
+    const parsed: unknown = parseYaml(match[1]);
+    if (parsed !== null && parsed !== undefined && typeof parsed !== 'object') {
+      return null;
+    }
+    return {
+      frontmatter: (parsed as Record<string, unknown>) ?? {},
+      body: match[2],
+    };
+  } catch {
+    const fallbackParsed = parseFrontmatterFallback(match[1]);
+    if (Object.keys(fallbackParsed).length > 0) {
+      return {
+        frontmatter: fallbackParsed,
+        body: match[2],
+      };
+    }
+    return null;
+  }
+}
+
+export function extractString(
+  fm: Record<string, unknown>,
+  key: string
+): string | undefined {
+  const val = fm[key];
+  if (typeof val === 'string' && val.length > 0) return val;
+  if (Array.isArray(val) && val.length > 0 && val.every(v => typeof v === 'string')) {
+    return val.map(v => `[${v}]`).join(' ');
+  }
+  return undefined;
+}
+
+export function normalizeStringArray(val: unknown): string[] | undefined {
+  if (val === undefined || val === null) return undefined;
+
+  if (Array.isArray(val)) {
+    return val.map(v => String(v).trim()).filter(Boolean);
+  }
+
+  if (typeof val === 'string') {
+    const trimmed = val.trim();
+    if (!trimmed) return undefined;
+    return trimmed.split(',').map(s => s.trim()).filter(Boolean);
+  }
+
+  return undefined;
+}
+
+export function extractStringArray(
+  fm: Record<string, unknown>,
+  key: string
+): string[] | undefined {
+  return normalizeStringArray(fm[key]);
+}
+
+export function extractBoolean(
+  fm: Record<string, unknown>,
+  key: string
+): boolean | undefined {
+  const val = fm[key];
+  if (typeof val === 'boolean') return val;
+  return undefined;
+}
+
+export function isRecord(value: unknown): value is Record<string, unknown> {
+  return value != null && typeof value === 'object' && !Array.isArray(value);
+}
+
+const MAX_SLUG_LENGTH = 64;
+const SLUG_PATTERN = /^[a-z0-9-]+$/;
+const YAML_RESERVED_WORDS = new Set(['true', 'false', 'null', 'yes', 'no', 'on', 'off']);
+
+export function validateSlugName(name: string, label: string): string | null {
+  if (!name) {
+    return `${label} name is required`;
+  }
+  if (name.length > MAX_SLUG_LENGTH) {
+    return `${label} name must be ${MAX_SLUG_LENGTH} characters or fewer`;
+  }
+  if (!SLUG_PATTERN.test(name)) {
+    return `${label} name can only contain lowercase letters, numbers, and hyphens`;
+  }
+  if (YAML_RESERVED_WORDS.has(name)) {
+    return `${label} name cannot be a YAML reserved word (true, false, null, yes, no, on, off)`;
+  }
+  return null;
+}