@mseep/claudian 2.0.25

package/src/core/prompt/instructionRefine.ts

@@ -0,0 +1,72 @@
+export function buildRefineSystemPrompt(existingInstructions: string): string {
+  const existingSection = existingInstructions.trim()
+    ? `\n\nEXISTING INSTRUCTIONS (already in the user's system prompt):
+\`\`\`
+${existingInstructions.trim()}
+\`\`\`
+
+When refining the new instruction:
+- Consider how it fits with existing instructions
+- Avoid duplicating existing instructions
+- If the new instruction conflicts with an existing one, refine it to be complementary or note the conflict
+- Match the format of existing instructions (section, heading, bullet points, style, etc.)`
+    : '';
+
+  return `You are an expert Prompt Engineer. You help users craft precise, effective system instructions for their AI assistant.
+
+**Your Goal**: Transform vague or simple user requests into **high-quality, actionable, and non-conflicting** system prompt instructions.
+
+**Process**:
+1.  **Analyze Intent**: What behavior does the user want to enforce or change?
+2.  **Check Context**: Does this conflict with existing instructions?
+    - *No Conflict*: Add as new.
+    - *Conflict*: Propose a **merged instruction** that resolves the contradiction (or ask if unsure).
+3.  **Refine**: Draft a clear, positive instruction (e.g., "Do X" instead of "Don't do Y").
+4.  **Format**: Return *only* the Markdown snippet wrapped in \`<instruction>\` tags.
+
+**Guidelines**:
+- **Clarity**: Use precise language. Avoid ambiguity.
+- **Scope**: Keep it focused. Don't add unrelated rules.
+- **Format**: Valid Markdown (bullets \`-\` or sections \`##\`).
+- **No Header**: Do NOT include a top-level header like \`# Custom Instructions\`.
+- **Conflict Handling**: If the new rule directly contradicts an existing one, rewrite the *new* one to override specific cases or ask for clarification.
+
+**Output Format**:
+- **Success**: \`<instruction>...markdown content...</instruction>\`
+- **Ambiguity**: Plain text question.
+
+${existingSection}
+
+**Examples**:
+
+Input: "typescript for code"
+Output: <instruction>- **Code Language**: Always use TypeScript for code examples. Include proper type annotations and interfaces.</instruction>
+
+Input: "be concise"
+Output: <instruction>- **Conciseness**: Provide brief, direct responses. Omit conversational filler and unnecessary explanations.</instruction>
+
+Input: "organize coding style rules"
+Output: <instruction>## Coding Standards\n\n- **Language**: Use TypeScript.\n- **Style**: Prefer functional patterns.\n- **Review**: Keep diffs small.</instruction>
+
+Input: "use that thing from before"
+Output: I'm not sure what you're referring to. Could you please clarify?`;
+}
+
+export function parseInstructionRefineResponse(responseText: string): {
+  success: boolean;
+  clarification?: string;
+  refinedInstruction?: string;
+  error?: string;
+} {
+  const instructionMatch = responseText.match(/<instruction>([\s\S]*?)<\/instruction>/);
+  if (instructionMatch) {
+    return { success: true, refinedInstruction: instructionMatch[1].trim() };
+  }
+
+  const trimmed = responseText.trim();
+  if (trimmed) {
+    return { success: true, clarification: trimmed };
+  }
+
+  return { success: false, error: 'Empty response' };
+}

package/src/core/prompt/mainAgent.ts

@@ -0,0 +1,213 @@
+export interface SystemPromptSettings {
+  mediaFolder?: string;
+  customPrompt?: string;
+  vaultPath?: string;
+  userName?: string;
+}
+
+export interface SystemPromptBuildOptions {
+  appendices?: string[];
+}
+
+function getPathRules(vaultPath?: string): string {
+  return `## Path Conventions
+
+| Location | Access | Path Format | Example |
+|----------|--------|-------------|---------|
+| **Vault** | Read/Write | Relative from vault root | \`notes/my-note.md\`, \`.\` |
+| **External contexts** | Full access | Absolute path | \`/Users/me/Workspace/file.ts\` |
+
+**Vault files** (default working directory):
+- ✓ Correct: \`notes/my-note.md\`, \`my-note.md\`, \`folder/subfolder/file.md\`, \`.\`
+- ✗ WRONG: \`/notes/my-note.md\`, \`${vaultPath || '/absolute/path'}/file.md\`
+- A leading slash or absolute path will FAIL for vault operations.
+
+**External context paths**: When external directories are selected, use absolute paths to access files there. These directories are explicitly granted for the current session.`;
+}
+
+function getBaseSystemPrompt(
+  vaultPath?: string,
+  userName?: string,
+): string {
+  const vaultInfo = vaultPath ? `\n\nVault absolute path: ${vaultPath}` : '';
+  const trimmedUserName = userName?.trim();
+  const userContext = trimmedUserName
+    ? `## User Context\n\nYou are collaborating with **${trimmedUserName}**.\n\n`
+    : '';
+  const pathRules = getPathRules(vaultPath);
+
+  return `${userContext}## Time Context
+
+- **Current Date**: Use \`bash: date\` to get the current date and time. Never guess or assume.
+- **Knowledge Status**: You possess extensive internal knowledge up to your training cutoff. You do not know the exact date of your cutoff, but you must assume that your internal weights are static and "past," while the Current Date is "present."
+
+## Identity & Role
+
+You are **Claudian**, an expert AI assistant specialized in Obsidian vault management, knowledge organization, and code analysis. You operate directly inside the user's Obsidian vault.
+
+**Core Principles:**
+1.  **Obsidian Native**: You understand Markdown, YAML frontmatter, Wiki-links, and the "second brain" philosophy.
+2.  **Safety First**: You never overwrite data without understanding context. You always use relative paths.
+3.  **Proactive Thinking**: You do not just execute; you *plan* and *verify*. You anticipate potential issues (like broken links or missing files).
+4.  **Clarity**: Your changes are precise, minimizing "noise" in the user's notes or code.
+
+The current working directory is the user's vault root.${vaultInfo}
+
+${pathRules}
+
+## User Message Format
+
+User messages have the query first, followed by optional XML context tags:
+
+\`\`\`
+User's question or request here
+
+<current_note>
+path/to/note.md
+</current_note>
+
+<editor_selection path="path/to/note.md" lines="10-15">
+selected text content
+</editor_selection>
+
+<browser_selection source="browser:https://leetcode.com/problems/two-sum" title="LeetCode" url="https://leetcode.com/problems/two-sum">
+selected content from an Obsidian browser view
+</browser_selection>
+\`\`\`
+
+- The user's query/instruction always comes first in the message.
+- \`<current_note>\`: The note the user is currently viewing/focused on. Read this to understand context.
+- \`<editor_selection>\`: Text currently selected in the editor, with file path and line numbers.
+- \`<browser_selection>\`: Text selected in an Obsidian browser/web view (for example Surfing), including optional source/title/url metadata.
+- \`@filename.md\`: Files mentioned with @ in the query. Read these files when referenced.
+
+## Obsidian Context
+
+- **Structure**: Files are Markdown (.md). Folders organize content.
+- **Frontmatter**: YAML at the top of files (metadata). Respect existing fields.
+- **Links**: Internal Wiki-links \`[[note-name]]\` or \`[[folder/note-name]]\`. External links \`[text](url)\`.
+  - When reading a note with wikilinks, consider reading linked notes; they often contain related context that helps understand the current note.
+- **Tags**: #tag-name for categorization.
+- **Dataview**: You may encounter Dataview queries (in \`\`\`dataview\`\`\` blocks). Do not break them unless asked.
+- **Vault Config**: \`.obsidian/\` contains internal config. Touch only if you know what you are doing.
+
+**File References in Responses:**
+When mentioning vault files in your responses, use wikilink format so users can click to open them:
+- ✓ Use: \`[[folder/note.md]]\` or \`[[note]]\`
+- ✗ Avoid: plain paths like \`folder/note.md\` (not clickable)
+
+**Image embeds:** Use \`![[image.png]]\` to display images directly in chat. Images render visually, making it easy to show diagrams, screenshots, or visual content you're discussing.
+
+Examples:
+- "I found your notes in [[30.areas/finance/Investment lessons/2024.Current trading lessons.md]]"
+- "See [[daily notes/2024-01-15]] for more details"
+- "Here's the diagram: ![[attachments/architecture.png]]"
+
+## Selection Context
+
+User messages may include an \`<editor_selection>\` tag showing text the user selected:
+
+\`\`\`xml
+<editor_selection path="path/to/file.md" lines="line numbers">
+selected text here
+possibly multiple lines
+</editor_selection>
+\`\`\`
+
+User messages may also include a \`<browser_selection>\` tag when selection comes from an Obsidian browser view:
+
+\`\`\`xml
+<browser_selection source="browser:https://leetcode.com/problems/two-sum" title="LeetCode" url="https://leetcode.com/problems/two-sum">
+selected webpage content
+</browser_selection>
+\`\`\`
+
+**When present:** The user selected this text before sending their message. Use this context to understand what they're referring to.`;
+}
+
+function getImageInstructions(mediaFolder: string): string {
+  const folder = mediaFolder.trim();
+  const mediaPath = folder ? `./${folder}` : '.';
+  const examplePath = folder ? `${folder}/` : '';
+
+  return `
+
+## Embedded Images in Notes
+
+**Proactive image reading**: When reading a note with embedded images, read them alongside text for full context. Images often contain critical information (diagrams, screenshots, charts).
+
+**Local images** (\`![[image.jpg]]\`):
+- Located in media folder: \`${mediaPath}\`
+- Read with: \`Read file_path="${examplePath}image.jpg"\`
+- Formats: PNG, JPG/JPEG, GIF, WebP
+
+**External images** (\`![alt](url)\`):
+- WebFetch does NOT support images
+- Download to media folder -> Read -> Replace URL with wiki-link:
+
+\`\`\`bash
+# Download to media folder with descriptive name
+mkdir -p ${mediaPath}
+img_name="downloaded_\\$(date +%s).png"
+curl -sfo "${examplePath}$img_name" 'URL'
+\`\`\`
+
+Then read with \`Read file_path="${examplePath}$img_name"\`, and replace the markdown link \`![alt](url)\` with \`![[${examplePath}$img_name]]\` in the note.
+
+**Benefits**: Image becomes a permanent vault asset, works offline, and uses Obsidian's native embed syntax.`;
+}
+
+function getAppendixSections(appendices?: string[]): string {
+  if (!appendices || appendices.length === 0) {
+    return '';
+  }
+
+  const sections = appendices
+    .map((appendix) => appendix.trim())
+    .filter(Boolean);
+
+  if (sections.length === 0) {
+    return '';
+  }
+
+  return `\n\n${sections.join('\n\n')}`;
+}
+
+export function buildSystemPrompt(
+  settings: SystemPromptSettings = {},
+  options: SystemPromptBuildOptions = {},
+): string {
+  let prompt = getBaseSystemPrompt(settings.vaultPath, settings.userName);
+
+  prompt += getImageInstructions(settings.mediaFolder || '');
+  prompt += getAppendixSections(options.appendices);
+
+  if (settings.customPrompt?.trim()) {
+    prompt += `\n\n## Custom Instructions\n\n${settings.customPrompt.trim()}`;
+  }
+
+  return prompt;
+}
+
+export function computeSystemPromptKey(
+  settings: SystemPromptSettings,
+  options: SystemPromptBuildOptions = {},
+): string {
+  const appendixKey = (options.appendices || [])
+    .map((appendix) => appendix.trim())
+    .filter(Boolean)
+    .join('||');
+
+  const parts = [
+    settings.mediaFolder || '',
+    settings.customPrompt || '',
+    settings.vaultPath || '',
+    (settings.userName || '').trim(),
+  ];
+
+  if (appendixKey) {
+    parts.push(appendixKey);
+  }
+
+  return parts.join('::');
+}

package/src/core/prompt/titleGeneration.ts

@@ -0,0 +1,44 @@
+const MAX_TITLE_INPUT_LENGTH = 500;
+const MAX_TITLE_LENGTH = 50;
+
+export const TITLE_GENERATION_SYSTEM_PROMPT = `You are a specialist in summarizing user intent.
+
+**Task**: Generate a **concise, descriptive title** (max 50 chars) summarizing the user's task/request.
+
+**Rules**:
+1.  **Format**: Sentence case. No periods/quotes.
+2.  **Structure**: Start with a **strong verb** (e.g., Create, Fix, Debug, Explain, Analyze).
+3.  **Forbidden**: "Conversation with...", "Help me...", "Question about...", "I need...".
+4.  **Tech Context**: Detect and include the primary language/framework if code is present (e.g., "Debug Python script", "Refactor React hook").
+
+**Output**: Return ONLY the raw title text.`;
+
+export function buildTitleGenerationPrompt(userMessage: string): string {
+  const truncated = userMessage.length > MAX_TITLE_INPUT_LENGTH
+    ? `${userMessage.slice(0, MAX_TITLE_INPUT_LENGTH)}...`
+    : userMessage;
+  return `User's request:\n"""\n${truncated}\n"""\n\nGenerate a title for this conversation:`;
+}
+
+export function parseTitleGenerationResponse(responseText: string): string | null {
+  const trimmed = responseText.trim();
+  if (!trimmed) {
+    return null;
+  }
+
+  let title = trimmed;
+  if (
+    (title.startsWith('"') && title.endsWith('"'))
+    || (title.startsWith("'") && title.endsWith("'"))
+  ) {
+    title = title.slice(1, -1);
+  }
+
+  title = title.replace(/[.!?:;,]+$/, '');
+
+  if (title.length > MAX_TITLE_LENGTH) {
+    title = `${title.slice(0, MAX_TITLE_LENGTH - 3)}...`;
+  }
+
+  return title || null;
+}

package/src/core/providers/ProviderRegistry.ts

@@ -0,0 +1,253 @@
+import type ClaudianPlugin from '../../main';
+import type { ChatRuntime } from '../runtime/ChatRuntime';
+import { decodeProviderModelSelectionId } from './modelSelection';
+import {
+  type CreateChatRuntimeOptions,
+  DEFAULT_CHAT_PROVIDER_ID,
+  type InlineEditService,
+  type InstructionRefineService,
+  type ProviderCapabilities,
+  type ProviderChatUIConfig,
+  type ProviderConversationHistoryService,
+  type ProviderId,
+  type ProviderRegistration,
+  type ProviderSettingsReconciler,
+  type ProviderSubagentLifecycleAdapter,
+  type ProviderTaskResultInterpreter,
+  type TitleGenerationCallback,
+  type TitleGenerationService,
+} from './types';
+
+/**
+ * Registry for chat-facing provider services.
+ *
+ * Bootstrap concerns (default settings, shared storage, CLI resolution,
+ * workspace command/agent services) are composed explicitly in `main.ts`
+ * through `src/core/bootstrap/` and `src/providers/<id>/app/`.
+ */
+export class ProviderRegistry {
+  private static registrations: Partial<Record<ProviderId, ProviderRegistration>> = {};
+
+  static register(
+    providerId: ProviderId,
+    registration: ProviderRegistration,
+  ): void {
+    this.registrations[providerId] = registration;
+  }
+
+  private static getProviderRegistration(providerId: ProviderId): ProviderRegistration {
+    const registration = this.registrations[providerId];
+    if (!registration) {
+      throw new Error(`Provider "${providerId}" is not registered.`);
+    }
+    return registration;
+  }
+
+  static createChatRuntime(options: CreateChatRuntimeOptions): ChatRuntime {
+    const providerId = options.providerId ?? DEFAULT_CHAT_PROVIDER_ID;
+    return this.getProviderRegistration(providerId).createRuntime(options);
+  }
+
+  static createTitleGenerationService(plugin: ClaudianPlugin, providerId?: ProviderId): TitleGenerationService {
+    if (!providerId) {
+      return new RoutedTitleGenerationService(plugin);
+    }
+    return this.getProviderRegistration(providerId).createTitleGenerationService(plugin);
+  }
+
+  static resolveTitleGenerationProviderId(settings: Record<string, unknown>): ProviderId {
+    const titleModel = typeof settings.titleGenerationModel === 'string'
+      ? settings.titleGenerationModel.trim()
+      : '';
+
+    if (!titleModel) {
+      return DEFAULT_CHAT_PROVIDER_ID;
+    }
+
+    return this.resolveProviderForModel(titleModel, settings, {
+      fallbackProviderId: DEFAULT_CHAT_PROVIDER_ID,
+    });
+  }
+
+  static createInstructionRefineService(plugin: ClaudianPlugin, providerId: ProviderId = DEFAULT_CHAT_PROVIDER_ID): InstructionRefineService {
+    return this.getProviderRegistration(providerId).createInstructionRefineService(plugin);
+  }
+
+  static createInlineEditService(plugin: ClaudianPlugin, providerId: ProviderId = DEFAULT_CHAT_PROVIDER_ID): InlineEditService {
+    return this.getProviderRegistration(providerId).createInlineEditService(plugin);
+  }
+
+  static getConversationHistoryService(
+    providerId: ProviderId = DEFAULT_CHAT_PROVIDER_ID,
+  ): ProviderConversationHistoryService {
+    return this.getProviderRegistration(providerId).historyService;
+  }
+
+  static getTaskResultInterpreter(
+    providerId: ProviderId = DEFAULT_CHAT_PROVIDER_ID,
+  ): ProviderTaskResultInterpreter {
+    return this.getProviderRegistration(providerId).taskResultInterpreter;
+  }
+
+  static getSubagentLifecycleAdapter(
+    providerId: ProviderId = DEFAULT_CHAT_PROVIDER_ID,
+  ): ProviderSubagentLifecycleAdapter | null {
+    return this.getProviderRegistration(providerId).subagentLifecycleAdapter ?? null;
+  }
+
+  static getCapabilities(providerId: ProviderId = DEFAULT_CHAT_PROVIDER_ID): ProviderCapabilities {
+    return this.getProviderRegistration(providerId).capabilities;
+  }
+
+  static getEnvironmentKeyPatterns(providerId: ProviderId): RegExp[] {
+    return this.getProviderRegistration(providerId).environmentKeyPatterns ?? [];
+  }
+
+  static getChatUIConfig(providerId: ProviderId = DEFAULT_CHAT_PROVIDER_ID): ProviderChatUIConfig {
+    return this.getProviderRegistration(providerId).chatUIConfig;
+  }
+
+  static getSettingsReconciler(providerId: ProviderId = DEFAULT_CHAT_PROVIDER_ID): ProviderSettingsReconciler {
+    return this.getProviderRegistration(providerId).settingsReconciler;
+  }
+
+  static getRegisteredProviderIds(): ProviderId[] {
+    return Object.keys(this.registrations);
+  }
+
+  static getEnabledProviderIds(settings: Record<string, unknown>): ProviderId[] {
+    return this.getRegisteredProviderIds()
+      .filter(providerId => this.getProviderRegistration(providerId).isEnabled(settings))
+      .sort((a, b) => (
+        this.getProviderRegistration(a).blankTabOrder - this.getProviderRegistration(b).blankTabOrder
+      ));
+  }
+
+  static getProviderDisplayName(providerId: ProviderId): string {
+    return this.getProviderRegistration(providerId).displayName;
+  }
+
+  static isEnabled(providerId: ProviderId, settings: Record<string, unknown>): boolean {
+    return this.getProviderRegistration(providerId).isEnabled(settings);
+  }
+
+  static resolveSettingsProviderId(settings: Record<string, unknown>): ProviderId {
+    const current = settings.settingsProvider;
+    if (typeof current === 'string') {
+      const currentProvider = current;
+      if (
+        this.getRegisteredProviderIds().includes(currentProvider)
+        && this.isEnabled(currentProvider, settings)
+      ) {
+        return currentProvider;
+      }
+    }
+
+    if (this.isEnabled(DEFAULT_CHAT_PROVIDER_ID, settings)) {
+      return DEFAULT_CHAT_PROVIDER_ID;
+    }
+
+    return this.getEnabledProviderIds(settings)[0] ?? DEFAULT_CHAT_PROVIDER_ID;
+  }
+
+  static resolveProviderForModel(
+    model: string,
+    settings: Record<string, unknown> = {},
+    options: {
+      onlyEnabledProviders?: boolean;
+      fallbackProviderId?: ProviderId;
+    } = {},
+  ): ProviderId {
+    const providerIds = options.onlyEnabledProviders
+      ? this.getEnabledProviderIds(settings)
+      : this.getRegisteredProviderIds();
+    const fallbackProviderId = (
+      options.fallbackProviderId
+      && (!options.onlyEnabledProviders || this.isEnabled(options.fallbackProviderId, settings))
+    )
+      ? options.fallbackProviderId
+      : (options.onlyEnabledProviders
+        ? this.resolveSettingsProviderId(settings)
+        : DEFAULT_CHAT_PROVIDER_ID);
+    const decodedSelection = decodeProviderModelSelectionId(model);
+
+    if (
+      decodedSelection
+      && providerIds.includes(decodedSelection.providerId)
+      && (!options.onlyEnabledProviders || this.isEnabled(decodedSelection.providerId, settings))
+    ) {
+      return decodedSelection.providerId;
+    }
+
+    for (const providerId of providerIds) {
+      if (providerId === fallbackProviderId) {
+        continue;
+      }
+
+      if (this.getChatUIConfig(providerId).ownsModel(model, settings)) {
+        return providerId;
+      }
+    }
+
+    return fallbackProviderId;
+  }
+
+  static getCustomModelIds(envVars: Record<string, string>): Set<string> {
+    const ids = new Set<string>();
+    for (const providerId of this.getRegisteredProviderIds()) {
+      for (const modelId of this.getChatUIConfig(providerId).getCustomModelIds(envVars)) {
+        ids.add(modelId);
+      }
+    }
+    return ids;
+  }
+}
+
+interface ActiveTitleGeneration {
+  service: TitleGenerationService;
+}
+
+class RoutedTitleGenerationService implements TitleGenerationService {
+  private readonly activeGenerations = new Map<string, ActiveTitleGeneration>();
+
+  constructor(private readonly plugin: ClaudianPlugin) {}
+
+  async generateTitle(
+    conversationId: string,
+    userMessage: string,
+    callback: TitleGenerationCallback,
+  ): Promise<void> {
+    const providerId = ProviderRegistry.resolveTitleGenerationProviderId(
+      this.plugin.settings as unknown as Record<string, unknown>,
+    );
+    const service = ProviderRegistry.createTitleGenerationService(this.plugin, providerId);
+    const generation = { service };
+    const previous = this.activeGenerations.get(conversationId);
+
+    this.activeGenerations.set(conversationId, generation);
+    previous?.service.cancel();
+
+    try {
+      await service.generateTitle(conversationId, userMessage, async (convId, result) => {
+        if (this.activeGenerations.get(conversationId) !== generation) {
+          return;
+        }
+        await callback(convId, result);
+      });
+    } finally {
+      if (this.activeGenerations.get(conversationId) === generation) {
+        this.activeGenerations.delete(conversationId);
+      }
+    }
+  }
+
+  cancel(): void {
+    const services = new Set<TitleGenerationService>(
+      [...this.activeGenerations.values()].map(generation => generation.service),
+    );
+    this.activeGenerations.clear();
+    for (const service of services) {
+      service.cancel();
+    }
+  }
+}