@mseep/claudian 2.0.25

package/src/core/mcp/McpServerManager.ts

@@ -0,0 +1,119 @@
+import { extractMcpMentions, transformMcpMentions } from '../../utils/mcp';
+import type { ManagedMcpServer, McpServerConfig } from '../types';
+
+/** Storage interface for loading MCP servers. */
+export interface McpStorageAdapter {
+  load(): Promise<ManagedMcpServer[]>;
+}
+
+export class McpServerManager {
+  private servers: ManagedMcpServer[] = [];
+  private storage: McpStorageAdapter;
+
+  constructor(storage: McpStorageAdapter) {
+    this.storage = storage;
+  }
+
+  async loadServers(): Promise<void> {
+    this.servers = await this.storage.load();
+  }
+
+  getServers(): ManagedMcpServer[] {
+    return this.servers;
+  }
+
+  getEnabledCount(): number {
+    return this.servers.filter((s) => s.enabled).length;
+  }
+
+  /**
+   * Get servers to include in SDK options.
+   *
+   * A server is included if:
+   * - It is enabled AND
+   * - Either context-saving is disabled OR the server is @-mentioned
+   *
+   * @param mentionedNames Set of server names that were @-mentioned in the prompt
+   */
+  getActiveServers(mentionedNames: Set<string>): Record<string, McpServerConfig> {
+    const result: Record<string, McpServerConfig> = {};
+
+    for (const server of this.servers) {
+      if (!server.enabled) continue;
+
+      // If context-saving is enabled, only include if @-mentioned
+      if (server.contextSaving && !mentionedNames.has(server.name)) {
+        continue;
+      }
+
+      result[server.name] = server.config;
+    }
+
+    return result;
+  }
+
+  /**
+   * Get disabled MCP tools formatted for SDK disallowedTools option.
+   *
+   * Only returns disabled tools from servers that would be active (same filter as getActiveServers).
+   *
+   * @param mentionedNames Set of server names that were @-mentioned in the prompt
+   */
+  getDisallowedMcpTools(mentionedNames: Set<string>): string[] {
+    return this.collectDisallowedTools(
+      (s) => !s.contextSaving || mentionedNames.has(s.name)
+    );
+  }
+
+  /**
+   * Get all disabled MCP tools from ALL enabled servers (ignoring @-mentions).
+   *
+   * Used for persistent queries to pre-register all disabled tools upfront,
+   * so @-mentioning servers doesn't require cold start.
+   */
+  getAllDisallowedMcpTools(): string[] {
+    return this.collectDisallowedTools().sort();
+  }
+
+  private collectDisallowedTools(filter?: (server: ManagedMcpServer) => boolean): string[] {
+    const disallowed = new Set<string>();
+
+    for (const server of this.servers) {
+      if (!server.enabled) continue;
+      if (filter && !filter(server)) continue;
+      if (!server.disabledTools || server.disabledTools.length === 0) continue;
+
+      for (const tool of server.disabledTools) {
+        const normalized = tool.trim();
+        if (!normalized) continue;
+        disallowed.add(`mcp__${server.name}__${normalized}`);
+      }
+    }
+
+    return Array.from(disallowed);
+  }
+
+  hasServers(): boolean {
+    return this.servers.length > 0;
+  }
+
+  getContextSavingServers(): ManagedMcpServer[] {
+    return this.servers.filter((s) => s.enabled && s.contextSaving);
+  }
+
+  private getContextSavingNames(): Set<string> {
+    return new Set(this.getContextSavingServers().map((s) => s.name));
+  }
+
+  /** Only matches against enabled servers with context-saving mode. */
+  extractMentions(text: string): Set<string> {
+    return extractMcpMentions(text, this.getContextSavingNames());
+  }
+
+  /**
+   * Appends " MCP" after each valid @mention. Applied to API requests only, not shown in UI.
+   */
+  transformMentions(text: string): string {
+    return transformMcpMentions(text, this.getContextSavingNames());
+  }
+}

package/src/core/mcp/McpTester.ts

@@ -0,0 +1,310 @@
+import { Client } from '@modelcontextprotocol/sdk/client';
+import { StdioClientTransport } from '@modelcontextprotocol/sdk/client/stdio';
+import { StreamableHTTPClientTransport } from '@modelcontextprotocol/sdk/client/streamableHttp';
+import type { Transport } from '@modelcontextprotocol/sdk/shared/transport';
+import * as http from 'http';
+import * as https from 'https';
+
+import { getEnhancedPath } from '../../utils/env';
+import { parseCommand } from '../../utils/mcp';
+import type { ManagedMcpServer } from '../types';
+import { getMcpServerType } from '../types';
+
+export interface McpTool {
+  name: string;
+  description?: string;
+  inputSchema?: Record<string, unknown>;
+}
+
+export interface McpTestResult {
+  success: boolean;
+  serverName?: string;
+  serverVersion?: string;
+  tools: McpTool[];
+  error?: string;
+}
+
+interface UrlServerConfig {
+  url: string;
+  headers?: Record<string, string>;
+}
+
+type StreamableHttpTransportOptions = ConstructorParameters<typeof StreamableHTTPClientTransport>[1];
+type LegacySseTransportConstructor = new (
+  url: URL,
+  options?: StreamableHttpTransportOptions,
+) => Transport;
+
+function createLegacySseTransport(url: URL, options: StreamableHttpTransportOptions): Transport {
+  // eslint-disable-next-line @typescript-eslint/no-require-imports -- Legacy SSE MCP servers still need the SDK's deprecated compatibility transport.
+  const module = require('@modelcontextprotocol/sdk/client/sse') as {
+    SSEClientTransport: LegacySseTransportConstructor;
+  };
+  return new module.SSEClientTransport(url, options);
+}
+
+/**
+ * Use Node's HTTP stack for MCP server verification to avoid renderer CORS restrictions.
+ * We still rely on official SDK transports for MCP protocol semantics.
+ */
+export function createNodeFetch(): (input: string | URL | Request, init?: RequestInit) => Promise<Response> {
+  return async (input: string | URL | Request, init?: RequestInit): Promise<Response> => {
+    const requestUrl = getRequestUrl(input);
+    const method = init?.method ?? (input instanceof Request ? input.method : 'GET');
+    const headers = mergeHeaders(input, init);
+    const signal = init?.signal ?? (input instanceof Request ? input.signal : undefined);
+    const body = await getRequestBody(init?.body ?? (input instanceof Request ? input.body : undefined));
+    const transport = requestUrl.protocol === 'https:' ? https : http;
+
+    return new Promise<Response>((resolve, reject) => {
+      let settled = false;
+
+      const fail = (error: unknown) => {
+        if (settled) return;
+        settled = true;
+        signal?.removeEventListener('abort', onAbort);
+        reject(error instanceof Error ? error : new Error(String(error)));
+      };
+
+      const onAbort = () => {
+        req.destroy(new Error('Request aborted'));
+        fail(signal?.reason ?? new Error('Request aborted'));
+      };
+
+      const requestHeaders: Record<string, string> = {};
+      headers.forEach((value, key) => {
+        requestHeaders[key] = value;
+      });
+      if (body) {
+        requestHeaders['content-length'] = String(body.byteLength);
+      }
+
+      const req = transport.request(
+        requestUrl,
+        {
+          method,
+          headers: requestHeaders,
+        },
+        (res: http.IncomingMessage) => {
+          if (settled) return;
+          settled = true;
+          signal?.removeEventListener('abort', onAbort);
+          resolve(createFetchResponse(res) as Response);
+        },
+      );
+
+      req.on('error', (error: Error) => fail(error));
+
+      if (signal) {
+        if (signal.aborted) {
+          onAbort();
+          return;
+        }
+        signal.addEventListener('abort', onAbort, { once: true });
+      }
+
+      if (body) {
+        req.end(body);
+      } else {
+        req.end();
+      }
+    });
+  };
+}
+
+interface MinimalFetchResponse {
+  ok: boolean;
+  status: number;
+  statusText: string;
+  headers: Headers;
+  body: ReadableStream<Uint8Array> | null;
+  text: () => Promise<string>;
+  json: () => Promise<unknown>;
+}
+
+function createFetchResponse(res: http.IncomingMessage): MinimalFetchResponse {
+  const responseHeaders = new Headers();
+  for (const [key, value] of Object.entries(res.headers)) {
+    if (value === undefined) continue;
+    if (Array.isArray(value)) {
+      for (const headerValue of value) {
+        responseHeaders.append(key, headerValue);
+      }
+    } else {
+      responseHeaders.append(key, value);
+    }
+  }
+
+  const body = new ReadableStream<Uint8Array>({
+    start(controller) {
+      res.on('data', (chunk: Buffer | string) => {
+        const buffer = typeof chunk === 'string' ? Buffer.from(chunk) : chunk;
+        controller.enqueue(new Uint8Array(buffer));
+      });
+      res.on('end', () => controller.close());
+      res.on('error', (error: Error) => controller.error(error));
+    },
+    cancel(reason?: unknown) {
+      res.destroy(reason instanceof Error ? reason : new Error('Response body cancelled'));
+    },
+  });
+
+  let bodyUsed = false;
+  const readAsText = async (): Promise<string> => {
+    if (bodyUsed) {
+      throw new TypeError('Body has already been consumed');
+    }
+    bodyUsed = true;
+    const reader = body.getReader();
+    const chunks: Uint8Array[] = [];
+    let total = 0;
+    let done = false;
+    try {
+      while (!done) {
+        const { value, done: streamDone } = await reader.read();
+        done = streamDone;
+        if (done) break;
+        if (value) {
+          chunks.push(value);
+          total += value.byteLength;
+        }
+      }
+    } finally {
+      reader.releaseLock();
+    }
+
+    const merged = new Uint8Array(total);
+    let offset = 0;
+    for (const chunk of chunks) {
+      merged.set(chunk, offset);
+      offset += chunk.byteLength;
+    }
+    return new TextDecoder().decode(merged);
+  };
+
+  return {
+    ok: (res.statusCode ?? 500) >= 200 && (res.statusCode ?? 500) < 300,
+    status: res.statusCode ?? 500,
+    statusText: res.statusMessage ?? '',
+    headers: responseHeaders,
+    body,
+    text: readAsText,
+    json: async () => {
+      const parsed: unknown = JSON.parse(await readAsText());
+      return parsed;
+    },
+  };
+}
+
+function getRequestUrl(input: string | URL | Request): URL {
+  if (input instanceof URL) {
+    return input;
+  }
+  if (typeof input === 'string') {
+    return new URL(input);
+  }
+  return new URL(input.url);
+}
+
+function mergeHeaders(input: string | URL | Request, init?: RequestInit): Headers {
+  const headers = new Headers(input instanceof Request ? input.headers : undefined);
+  if (init?.headers) {
+    const initHeaders = new Headers(init.headers);
+    initHeaders.forEach((value, key) => {
+      headers.set(key, value);
+    });
+  }
+  return headers;
+}
+
+async function getRequestBody(body: BodyInit | null | undefined): Promise<Buffer | undefined> {
+  if (body === undefined || body === null) {
+    return undefined;
+  }
+
+  const serialized = await new Response(body).arrayBuffer();
+  return Buffer.from(serialized);
+}
+
+const nodeFetch = createNodeFetch();
+
+export async function testMcpServer(server: ManagedMcpServer): Promise<McpTestResult> {
+  const type = getMcpServerType(server.config);
+
+  let transport: Transport;
+  try {
+    if (type === 'stdio') {
+      const config = server.config as { command: string; args?: string[]; env?: Record<string, string> };
+      const { cmd, args } = parseCommand(config.command, config.args);
+      if (!cmd) {
+        return { success: false, tools: [], error: 'Missing command' };
+      }
+      transport = new StdioClientTransport({
+        command: cmd,
+        args,
+        env: { ...process.env, ...config.env, PATH: getEnhancedPath(config.env?.PATH) },
+        stderr: 'ignore',
+      });
+    } else {
+      const config = server.config as UrlServerConfig;
+      const url = new URL(config.url);
+      const options = {
+        fetch: nodeFetch,
+        requestInit: config.headers ? { headers: config.headers } : undefined,
+      };
+      transport = type === 'sse'
+        ? createLegacySseTransport(url, options)
+        : new StreamableHTTPClientTransport(url, options);
+    }
+  } catch (error) {
+    return {
+      success: false,
+      tools: [],
+      error: error instanceof Error ? error.message : 'Invalid server configuration',
+    };
+  }
+
+  const client = new Client({ name: 'claudian-tester', version: '1.0.0' });
+  const controller = new AbortController();
+  const timeout = window.setTimeout(() => controller.abort(), 10000);
+
+  try {
+    await client.connect(transport, { signal: controller.signal });
+
+    const serverVersion = client.getServerVersion();
+    let tools: McpTool[] = [];
+    try {
+      const result = await client.listTools(undefined, { signal: controller.signal });
+      tools = result.tools.map((t: { name: string; description?: string; inputSchema?: Record<string, unknown> }) => ({
+        name: t.name,
+        description: t.description,
+        inputSchema: t.inputSchema as Record<string, unknown>,
+      }));
+    } catch {
+      // listTools failure after successful connect = partial success
+    }
+
+    return {
+      success: true,
+      serverName: serverVersion?.name,
+      serverVersion: serverVersion?.version,
+      tools,
+    };
+  } catch (error) {
+    if (controller.signal.aborted) {
+      return { success: false, tools: [], error: 'Connection timeout (10s)' };
+    }
+    return {
+      success: false,
+      tools: [],
+      error: error instanceof Error ? error.message : 'Unknown error',
+    };
+  } finally {
+    window.clearTimeout(timeout);
+    try {
+      await client.close();
+    } catch {
+      // Ignore close errors
+    }
+  }
+}

package/src/core/prompt/inlineEdit.ts

@@ -0,0 +1,252 @@
+import { appendContextFiles } from '../../utils/context';
+import { getTodayDate } from '../../utils/date';
+import type {
+  InlineEditCursorRequest,
+  InlineEditRequest,
+  InlineEditResult,
+} from '../providers/types';
+
+export function parseInlineEditResponse(responseText: string): InlineEditResult {
+  const replacementMatch = responseText.match(/<replacement>([\s\S]*?)<\/replacement>/);
+  if (replacementMatch) {
+    return { success: true, editedText: replacementMatch[1] };
+  }
+
+  const insertionMatch = responseText.match(/<insertion>([\s\S]*?)<\/insertion>/);
+  if (insertionMatch) {
+    return { success: true, insertedText: insertionMatch[1] };
+  }
+
+  const trimmed = responseText.trim();
+  if (trimmed) {
+    return { success: true, clarification: trimmed };
+  }
+
+  return { success: false, error: 'Empty response' };
+}
+
+function buildCursorPrompt(request: InlineEditCursorRequest): string {
+  const ctx = request.cursorContext;
+  const lineAttr = ` line="${ctx.line + 1}"`;
+
+  let cursorContent: string;
+  if (ctx.isInbetween) {
+    const parts = [];
+    if (ctx.beforeCursor) parts.push(ctx.beforeCursor);
+    parts.push('| #inbetween');
+    if (ctx.afterCursor) parts.push(ctx.afterCursor);
+    cursorContent = parts.join('\n');
+  } else {
+    cursorContent = `${ctx.beforeCursor}|${ctx.afterCursor} #inline`;
+  }
+
+  return [
+    request.instruction,
+    '',
+    `<editor_cursor path="${request.notePath}"${lineAttr}>`,
+    cursorContent,
+    '</editor_cursor>',
+  ].join('\n');
+}
+
+export function buildInlineEditPrompt(request: InlineEditRequest): string {
+  let prompt: string;
+
+  if (request.mode === 'cursor') {
+    prompt = buildCursorPrompt(request);
+  } else {
+    const lineAttr = request.startLine && request.lineCount
+      ? ` lines="${request.startLine}-${request.startLine + request.lineCount - 1}"`
+      : '';
+    prompt = [
+      request.instruction,
+      '',
+      `<editor_selection path="${request.notePath}"${lineAttr}>`,
+      request.selectedText,
+      '</editor_selection>',
+    ].join('\n');
+  }
+
+  if (request.contextFiles && request.contextFiles.length > 0) {
+    prompt = appendContextFiles(prompt, request.contextFiles);
+  }
+
+  return prompt;
+}
+
+export function getInlineEditSystemPrompt(): string {
+  const pathRules = '- **Paths**: Must be RELATIVE to vault root (e.g., "notes/file.md").';
+
+  return `Today is ${getTodayDate()}.
+
+You are **Claudian**, an expert editor and writing assistant embedded in Obsidian. You help users refine their text, answer questions, and generate content with high precision.
+
+## Core Directives
+
+1.  **Style Matching**: Mimic the user's tone, voice, and formatting style (indentation, bullet points, capitalization).
+2.  **Context Awareness**: Always Read the full file (or significant context) to understand the broader topic before editing. Do not rely solely on the selection.
+3.  **Silent Execution**: Use tools (Read, WebSearch) silently. Your final output must be ONLY the result.
+4.  **No Fluff**: No pleasantries, no "Here is the text", no "I have updated...". Just the content.
+
+## Input Format
+
+User messages have the instruction first, followed by XML context tags:
+
+### Selection Mode
+\`\`\`
+user's instruction
+
+<editor_selection path="path/to/file.md">
+selected text here
+</editor_selection>
+\`\`\`
+Use \`<replacement>\` tags for edits.
+
+### Cursor Mode
+\`\`\`
+user's instruction
+
+<editor_cursor path="path/to/file.md">
+text before|text after #inline
+</editor_cursor>
+\`\`\`
+Or between paragraphs:
+\`\`\`
+user's instruction
+
+<editor_cursor path="path/to/file.md">
+Previous paragraph
+| #inbetween
+Next paragraph
+</editor_cursor>
+\`\`\`
+Use \`<insertion>\` tags to insert new content at the cursor position (\`|\`).
+
+## Tools & Path Rules
+
+- **Tools**: Read, Grep, Glob, LS, WebSearch, WebFetch. (All read-only).
+${pathRules}
+
+## Thinking Process
+
+Before generating the final output, mentally check:
+1.  **Context**: Have I read enough of the file to understand the *topic* and *structure*?
+2.  **Style**: What is the user's indentation (2 vs 4 spaces, tabs)? What is their tone?
+3.  **Type**: Is this **Prose** (flow, grammar, clarity) or **Code** (syntax, logic, variable names)?
+    - *Prose*: Ensure smooth transitions.
+    - *Code*: Preserve syntax validity; do not break surrounding brackets/indentation.
+
+## Output Rules - CRITICAL
+
+**ABSOLUTE RULE**: Your text output must contain ONLY the final answer, replacement, or insertion. NEVER output:
+- "I'll read the file..." / "Let me check..." / "I will..."
+- "I'm asked about..." / "The user wants..."
+- "Based on my analysis..." / "After reading..."
+- "Here's..." / "The answer is..."
+- ANY announcement of what you're about to do or did
+
+Use tools silently. Your text output = final result only.
+
+### When Replacing Selected Text (Selection Mode)
+
+If the user wants to MODIFY or REPLACE the selected text, wrap the replacement in <replacement> tags:
+
+<replacement>your replacement text here</replacement>
+
+The content inside the tags should be ONLY the replacement text - no explanation.
+
+### When Inserting at Cursor (Cursor Mode)
+
+If the user wants to INSERT new content at the cursor position, wrap the insertion in <insertion> tags:
+
+<insertion>your inserted text here</insertion>
+
+The content inside the tags should be ONLY the text to insert - no explanation.
+
+### When Answering Questions or Providing Information
+
+If the user is asking a QUESTION, respond WITHOUT tags. Output the answer directly.
+
+WRONG: "I'll read the full context of this file to give you a better explanation. This is a guide about..."
+CORRECT: "This is a guide about..."
+
+### When Clarification is Needed
+
+If the request is ambiguous, ask a clarifying question. Keep questions concise and specific.
+
+## Examples
+
+### Selection Mode
+Input:
+\`\`\`
+translate to French
+
+<editor_selection path="notes/readme.md">
+Hello world
+</editor_selection>
+\`\`\`
+
+CORRECT (replacement):
+<replacement>Bonjour le monde</replacement>
+
+Input:
+\`\`\`
+what does this do?
+
+<editor_selection path="notes/code.md">
+const x = arr.reduce((a, b) => a + b, 0);
+</editor_selection>
+\`\`\`
+
+CORRECT (question - no tags):
+This code sums all numbers in the array \`arr\`. It uses \`reduce\` to iterate through the array, accumulating the total starting from 0.
+
+### Cursor Mode
+
+Input:
+\`\`\`
+what animal?
+
+<editor_cursor path="notes/draft.md">
+The quick brown | jumps over the lazy dog. #inline
+</editor_cursor>
+\`\`\`
+
+CORRECT (insertion):
+<insertion>fox</insertion>
+
+### Q&A
+Input:
+\`\`\`
+add a brief description section
+
+<editor_cursor path="notes/readme.md">
+# Introduction
+This is my project.
+| #inbetween
+## Features
+</editor_cursor>
+\`\`\`
+
+CORRECT (insertion):
+<insertion>
+## Description
+
+This project provides tools for managing your notes efficiently.
+</insertion>
+
+Input:
+\`\`\`
+translate to Spanish
+
+<editor_selection path="notes/draft.md">
+The bank was steep.
+</editor_selection>
+\`\`\`
+
+CORRECT (asking for clarification):
+"Bank" can mean a financial institution (banco) or a river bank (orilla). Which meaning should I use?
+
+Then after user clarifies "river bank":
+<replacement>La orilla era empinada.</replacement>`;
+}