@mseep/claudian 2.0.25

package/src/features/chat/constants.ts

@@ -0,0 +1,114 @@
+/** Random flavor words shown when response completes (e.g., "Baked for 1:23"). */
+export const COMPLETION_FLAVOR_WORDS = [
+  'Baked',
+  'Cooked',
+  'Crunched',
+  'Brewed',
+  'Crafted',
+  'Forged',
+  'Conjured',
+  'Whipped up',
+  'Stirred',
+  'Simmered',
+  'Toasted',
+  'Sautéed',
+  'Finagled',
+  'Marinated',
+  'Distilled',
+  'Fermented',
+  'Percolated',
+  'Steeped',
+  'Roasted',
+  'Cured',
+  'Smoked',
+  'Cogitated',
+] as const;
+
+/** Random flavor texts shown while Claude is thinking. */
+export const FLAVOR_TEXTS = [
+  // Classic
+  'Thinking...',
+  'Pondering...',
+  'Processing...',
+  'Analyzing...',
+  'Considering...',
+  'Working on it...',
+  'Vibing...',
+  'One moment...',
+  'On it...',
+  // Thoughtful
+  'Ruminating...',
+  'Contemplating...',
+  'Reflecting...',
+  'Mulling it over...',
+  'Let me think...',
+  'Hmm...',
+  'Cogitating...',
+  'Deliberating...',
+  'Weighing options...',
+  'Gathering thoughts...',
+  // Playful
+  'Brewing ideas...',
+  'Connecting dots...',
+  'Assembling thoughts...',
+  'Spinning up neurons...',
+  'Loading brilliance...',
+  'Consulting the oracle...',
+  'Summoning knowledge...',
+  'Crunching thoughts...',
+  'Dusting off neurons...',
+  'Wrangling ideas...',
+  'Herding thoughts...',
+  'Juggling concepts...',
+  'Untangling this...',
+  'Piecing it together...',
+  // Cozy
+  'Sipping coffee...',
+  'Warming up...',
+  'Getting cozy with this...',
+  'Settling in...',
+  'Making tea...',
+  'Grabbing a snack...',
+  // Technical
+  'Parsing...',
+  'Compiling thoughts...',
+  'Running inference...',
+  'Querying the void...',
+  'Defragmenting brain...',
+  'Allocating memory...',
+  'Optimizing...',
+  'Indexing...',
+  'Syncing neurons...',
+  // Zen
+  'Breathing...',
+  'Finding clarity...',
+  'Channeling focus...',
+  'Centering...',
+  'Aligning chakras...',
+  'Meditating on this...',
+  // Whimsical
+  'Asking the stars...',
+  'Reading tea leaves...',
+  'Shaking the magic 8-ball...',
+  'Consulting ancient scrolls...',
+  'Decoding the matrix...',
+  'Communing with the ether...',
+  'Peering into the abyss...',
+  'Channeling the cosmos...',
+  // Action
+  'Diving in...',
+  'Rolling up sleeves...',
+  'Getting to work...',
+  'Tackling this...',
+  'On the case...',
+  'Investigating...',
+  'Exploring...',
+  'Digging deeper...',
+  // Casual
+  'Bear with me...',
+  'Hang tight...',
+  'Just a sec...',
+  'Working my magic...',
+  'Almost there...',
+  'Give me a moment...',
+];

package/src/features/chat/controllers/BrowserSelectionController.ts

@@ -0,0 +1,295 @@
+import type { App, ItemView } from 'obsidian';
+
+import type { BrowserSelectionContext } from '../../../utils/browser';
+import { updateContextRowHasContent } from './contextRowVisibility';
+
+const BROWSER_SELECTION_POLL_INTERVAL = 250;
+
+type BrowserLikeWebview = HTMLElement & {
+  executeJavaScript?: (code: string, userGesture?: boolean) => Promise<unknown>;
+};
+
+export class BrowserSelectionController {
+  private app: App;
+  private indicatorEl: HTMLElement;
+  private inputEl: HTMLElement;
+  private contextRowEl: HTMLElement;
+  private onVisibilityChange: (() => void) | null;
+  private storedSelection: BrowserSelectionContext | null = null;
+  private pollInterval: number | null = null;
+  private pollInFlight = false;
+
+  constructor(
+    app: App,
+    indicatorEl: HTMLElement,
+    inputEl: HTMLElement,
+    contextRowEl: HTMLElement,
+    onVisibilityChange?: () => void
+  ) {
+    this.app = app;
+    this.indicatorEl = indicatorEl;
+    this.inputEl = inputEl;
+    this.contextRowEl = contextRowEl;
+    this.onVisibilityChange = onVisibilityChange ?? null;
+  }
+
+  start(): void {
+    if (this.pollInterval) return;
+    this.pollInterval = window.setInterval(() => {
+      void this.poll();
+    }, BROWSER_SELECTION_POLL_INTERVAL);
+  }
+
+  stop(): void {
+    if (this.pollInterval) {
+      window.clearInterval(this.pollInterval);
+      this.pollInterval = null;
+    }
+    this.clear();
+  }
+
+  private async poll(): Promise<void> {
+    if (this.pollInFlight) return;
+    this.pollInFlight = true;
+    try {
+      const browserView = this.getActiveBrowserView();
+      if (!browserView) {
+        this.clearWhenInputIsNotFocused();
+        return;
+      }
+
+      const selectedText = await this.extractSelectedText(browserView.containerEl);
+      if (selectedText) {
+        const nextContext = this.buildContext(browserView.view, browserView.viewType, browserView.containerEl, selectedText);
+        if (!this.isSameSelection(nextContext, this.storedSelection)) {
+          this.storedSelection = nextContext;
+          this.updateIndicator();
+        }
+      } else {
+        this.clearWhenInputIsNotFocused();
+      }
+    } catch {
+      // Ignore transient polling errors to keep selection tracking resilient.
+    } finally {
+      this.pollInFlight = false;
+    }
+  }
+
+  private getActiveBrowserView(): { view: ItemView; viewType: string; containerEl: HTMLElement } | null {
+    const activeLeaf = this.app.workspace.getMostRecentLeaf?.();
+    const activeView = activeLeaf?.view as ItemView | undefined;
+    const containerEl = (activeView as unknown as { containerEl?: HTMLElement }).containerEl;
+    if (!activeView || !containerEl) return null;
+
+    const viewType = activeView.getViewType?.() ?? '';
+    if (!this.isBrowserLikeView(viewType, containerEl)) return null;
+
+    return { view: activeView, viewType, containerEl };
+  }
+
+  private isBrowserLikeView(viewType: string, containerEl: HTMLElement): boolean {
+    const normalized = viewType.toLowerCase();
+    if (
+      normalized.includes('surfing')
+      || normalized.includes('browser')
+      || normalized.includes('webview')
+    ) {
+      return true;
+    }
+
+    return Boolean(containerEl.querySelector('iframe, webview'));
+  }
+
+  private async extractSelectedText(containerEl: HTMLElement): Promise<string | null> {
+    const ownerDoc = containerEl.ownerDocument;
+    const docSelection = this.extractSelectionFromDocument(ownerDoc, containerEl);
+    if (docSelection) return docSelection;
+
+    const frameSelection = this.extractSelectionFromIframes(containerEl);
+    if (frameSelection) return frameSelection;
+
+    return await this.extractSelectionFromWebviews(containerEl);
+  }
+
+  private extractSelectionFromDocument(doc: Document, scopeEl: HTMLElement): string | null {
+    const selection = doc.getSelection();
+    const selectedText = selection?.toString().trim();
+    if (selectedText) {
+      const anchorNode = selection?.anchorNode;
+      const focusNode = selection?.focusNode;
+      if ((anchorNode && scopeEl.contains(anchorNode)) || (focusNode && scopeEl.contains(focusNode))) {
+        return selectedText;
+      }
+    }
+
+    return this.extractSelectionFromActiveInput(doc, scopeEl);
+  }
+
+  private extractSelectionFromActiveInput(doc: Document, scopeEl: HTMLElement): string | null {
+    const activeEl = doc.activeElement;
+    if (!activeEl || !scopeEl.contains(activeEl)) return null;
+
+    if (activeEl.instanceOf(HTMLTextAreaElement) || activeEl.instanceOf(HTMLInputElement)) {
+      const { value, selectionStart, selectionEnd } = activeEl;
+      if (typeof selectionStart !== 'number' || typeof selectionEnd !== 'number' || selectionStart === selectionEnd) return null;
+      return value.slice(selectionStart, selectionEnd).trim() || null;
+    }
+
+    return null;
+  }
+
+  private extractSelectionFromIframes(containerEl: HTMLElement): string | null {
+    const iframes = Array.from(containerEl.querySelectorAll('iframe'));
+    for (const iframe of iframes) {
+      try {
+        const frameDoc = iframe.contentDocument ?? iframe.contentWindow?.document;
+        if (!frameDoc || !frameDoc.body) continue;
+
+        const frameSelection = this.extractSelectionFromDocument(frameDoc, frameDoc.body);
+        if (frameSelection) return frameSelection;
+      } catch {
+        // Ignore inaccessible iframe contexts (cross-origin restrictions).
+      }
+    }
+    return null;
+  }
+
+  private async extractSelectionFromWebviews(containerEl: HTMLElement): Promise<string | null> {
+    const webviews = Array.from(containerEl.querySelectorAll<BrowserLikeWebview>('webview'));
+    for (const webview of webviews) {
+      if (typeof webview.executeJavaScript !== 'function') continue;
+      try {
+        const result = await webview.executeJavaScript(
+          'window.getSelection ? window.getSelection().toString() : ""',
+          true
+        );
+        if (typeof result === 'string' && result.trim()) {
+          return result.trim();
+        }
+      } catch {
+        // Ignore inaccessible webview contexts.
+      }
+    }
+    return null;
+  }
+
+  private buildContext(
+    view: ItemView,
+    viewType: string,
+    containerEl: HTMLElement,
+    selectedText: string
+  ): BrowserSelectionContext {
+    const title = this.extractViewTitle(view);
+    const url = this.extractViewUrl(view, containerEl);
+    const source = url ? `browser:${url}` : `browser:${viewType || 'unknown'}`;
+
+    return {
+      source,
+      selectedText,
+      title,
+      url,
+    };
+  }
+
+  private extractViewTitle(view: ItemView): string | undefined {
+    const displayText = view.getDisplayText?.();
+    if (displayText?.trim()) return displayText.trim();
+
+    const title = (view as unknown as { title?: unknown }).title;
+    return typeof title === 'string' && title.trim() ? title.trim() : undefined;
+  }
+
+  private extractViewUrl(view: ItemView, containerEl: HTMLElement): string | undefined {
+    const rawView = view as unknown as Record<string, unknown>;
+    const directCandidates = [
+      rawView.url,
+      rawView.currentUrl,
+      rawView.currentURL,
+      rawView.src,
+    ];
+
+    for (const candidate of directCandidates) {
+      if (typeof candidate === 'string' && candidate.trim()) {
+        return candidate.trim();
+      }
+    }
+
+    const embeddableEl = containerEl.querySelector<HTMLElement>('iframe[src], webview[src]');
+    const embeddedSrc = embeddableEl?.getAttribute('src');
+    if (embeddedSrc?.trim()) {
+      return embeddedSrc.trim();
+    }
+
+    return undefined;
+  }
+
+  private isSameSelection(
+    left: BrowserSelectionContext | null,
+    right: BrowserSelectionContext | null
+  ): boolean {
+    if (!left || !right) return false;
+    return left.source === right.source
+      && left.selectedText === right.selectedText
+      && left.title === right.title
+      && left.url === right.url;
+  }
+
+  private clearWhenInputIsNotFocused(): void {
+    if (this.inputEl.ownerDocument.activeElement === this.inputEl) return;
+    if (this.storedSelection) {
+      this.storedSelection = null;
+      this.updateIndicator();
+    }
+  }
+
+  private updateIndicator(): void {
+    if (!this.indicatorEl) return;
+
+    if (this.storedSelection) {
+      const lineCount = this.storedSelection.selectedText.split(/\r?\n/).length;
+      const lineLabel = lineCount === 1 ? 'line' : 'lines';
+      this.indicatorEl.textContent = `${lineCount} ${lineLabel} selected`;
+      this.indicatorEl.setAttribute('title', this.buildIndicatorTitle());
+      this.indicatorEl.removeClass('claudian-hidden');
+    } else {
+      this.indicatorEl.addClass('claudian-hidden');
+      this.indicatorEl.textContent = '';
+      this.indicatorEl.removeAttribute('title');
+    }
+    this.updateContextRowVisibility();
+  }
+
+  private buildIndicatorTitle(): string {
+    if (!this.storedSelection) return '';
+
+    const charCount = this.storedSelection.selectedText.length;
+    const charLabel = charCount === 1 ? 'char' : 'chars';
+    const lines = [`${charCount} ${charLabel} selected`, `source=${this.storedSelection.source}`];
+    if (this.storedSelection.title) {
+      lines.push(`title=${this.storedSelection.title}`);
+    }
+    if (this.storedSelection.url) {
+      lines.push(this.storedSelection.url);
+    }
+    return lines.join('\n');
+  }
+
+  updateContextRowVisibility(): void {
+    if (!this.contextRowEl) return;
+    updateContextRowHasContent(this.contextRowEl);
+    this.onVisibilityChange?.();
+  }
+
+  getContext(): BrowserSelectionContext | null {
+    return this.storedSelection;
+  }
+
+  hasSelection(): boolean {
+    return this.storedSelection !== null;
+  }
+
+  clear(): void {
+    this.storedSelection = null;
+    this.updateIndicator();
+  }
+}

package/src/features/chat/controllers/CanvasSelectionController.ts

@@ -0,0 +1,142 @@
+import type { App, ItemView } from 'obsidian';
+
+import type { CanvasSelectionContext } from '../../../utils/canvas';
+import { updateContextRowHasContent } from './contextRowVisibility';
+
+const CANVAS_POLL_INTERVAL = 250;
+
+type CanvasSelectionNode = { id?: unknown };
+
+type CanvasViewLike = ItemView & {
+  canvas?: {
+    selection?: Set<CanvasSelectionNode>;
+  };
+  file?: {
+    path?: unknown;
+  };
+};
+
+export class CanvasSelectionController {
+  private app: App;
+  private indicatorEl: HTMLElement;
+  private inputEl: HTMLElement;
+  private contextRowEl: HTMLElement;
+  private onVisibilityChange: (() => void) | null;
+  private storedSelection: CanvasSelectionContext | null = null;
+  private pollInterval: number | null = null;
+
+  constructor(
+    app: App,
+    indicatorEl: HTMLElement,
+    inputEl: HTMLElement,
+    contextRowEl: HTMLElement,
+    onVisibilityChange?: () => void
+  ) {
+    this.app = app;
+    this.indicatorEl = indicatorEl;
+    this.inputEl = inputEl;
+    this.contextRowEl = contextRowEl;
+    this.onVisibilityChange = onVisibilityChange ?? null;
+  }
+
+  start(): void {
+    if (this.pollInterval) return;
+    this.pollInterval = window.setInterval(() => this.poll(), CANVAS_POLL_INTERVAL);
+  }
+
+  stop(): void {
+    if (this.pollInterval) {
+      window.clearInterval(this.pollInterval);
+      this.pollInterval = null;
+    }
+    this.clear();
+  }
+
+  private poll(): void {
+    const canvasView = this.getCanvasView();
+    if (!canvasView) return;
+
+    const canvas = canvasView.canvas;
+    if (!canvas?.selection) return;
+
+    const selection = canvas.selection;
+    const canvasPath = canvasView.file?.path;
+    if (typeof canvasPath !== 'string' || !canvasPath) return;
+
+    const nodeIds = [...selection]
+      .map(node => node.id)
+      .filter((id): id is string => typeof id === 'string' && id.length > 0);
+
+    if (nodeIds.length > 0) {
+      const sameSelection = this.storedSelection
+        && this.storedSelection.canvasPath === canvasPath
+        && this.storedSelection.nodeIds.length === nodeIds.length
+        && this.storedSelection.nodeIds.every(id => nodeIds.includes(id));
+
+      if (!sameSelection) {
+        this.storedSelection = { canvasPath, nodeIds };
+        this.updateIndicator();
+      }
+    } else if (this.getActiveElement() !== this.inputEl) {
+      if (this.storedSelection) {
+        this.storedSelection = null;
+        this.updateIndicator();
+      }
+    }
+  }
+
+  private getActiveElement(): Element | null {
+    return this.inputEl.ownerDocument?.activeElement ?? null;
+  }
+
+  private getCanvasView(): CanvasViewLike | null {
+    const activeLeaf = this.app.workspace.getMostRecentLeaf?.();
+    const activeView = activeLeaf?.view as CanvasViewLike | undefined;
+    if (activeView?.getViewType?.() === 'canvas' && activeView.file) {
+      return activeView;
+    }
+
+    const leaves = this.app.workspace.getLeavesOfType('canvas');
+    if (leaves.length === 0) return null;
+    const leaf = leaves.find(l => (l.view as CanvasViewLike).file);
+    return leaf ? (leaf.view as CanvasViewLike) : null;
+  }
+
+  private updateIndicator(): void {
+    if (!this.indicatorEl) return;
+
+    if (this.storedSelection) {
+      const { nodeIds } = this.storedSelection;
+      this.indicatorEl.textContent = nodeIds.length === 1
+        ? `node "${nodeIds[0]}" selected`
+        : `${nodeIds.length} nodes selected`;
+      this.indicatorEl.removeClass('claudian-hidden');
+    } else {
+      this.indicatorEl.addClass('claudian-hidden');
+    }
+    this.updateContextRowVisibility();
+  }
+
+  updateContextRowVisibility(): void {
+    if (!this.contextRowEl) return;
+    updateContextRowHasContent(this.contextRowEl);
+    this.onVisibilityChange?.();
+  }
+
+  getContext(): CanvasSelectionContext | null {
+    if (!this.storedSelection) return null;
+    return {
+      canvasPath: this.storedSelection.canvasPath,
+      nodeIds: [...this.storedSelection.nodeIds],
+    };
+  }
+
+  hasSelection(): boolean {
+    return this.storedSelection !== null;
+  }
+
+  clear(): void {
+    this.storedSelection = null;
+    this.updateIndicator();
+  }
+}