@mseep/claudian 2.0.25

package/src/providers/claude/auxiliary/ClaudeTitleGenerationService.ts

@@ -0,0 +1,129 @@
+import { TITLE_GENERATION_SYSTEM_PROMPT } from '../../../core/prompt/titleGeneration';
+import type {
+  TitleGenerationCallback,
+  TitleGenerationResult,
+} from '../../../core/providers/types';
+import type ClaudianPlugin from '../../../main';
+import { parseEnvironmentVariables } from '../../../utils/env';
+import { toClaudeRuntimeModelId } from '../modelSelection';
+import { runColdStartQuery } from '../runtime/claudeColdStartQuery';
+import { claudeChatUIConfig } from '../ui/ClaudeChatUIConfig';
+
+export type { TitleGenerationResult };
+
+export class TitleGenerationService {
+  private plugin: ClaudianPlugin;
+  private activeGenerations: Map<string, AbortController> = new Map();
+
+  constructor(plugin: ClaudianPlugin) {
+    this.plugin = plugin;
+  }
+
+  async generateTitle(
+    conversationId: string,
+    userMessage: string,
+    callback: TitleGenerationCallback
+  ): Promise<void> {
+    // Cancel any existing generation for this conversation
+    const existingController = this.activeGenerations.get(conversationId);
+    if (existingController) {
+      existingController.abort();
+    }
+
+    const abortController = new AbortController();
+    this.activeGenerations.set(conversationId, abortController);
+
+    const truncatedUser = this.truncateText(userMessage, 500);
+    const prompt = `User's request:\n"""\n${truncatedUser}\n"""\n\nGenerate a title for this conversation:`;
+
+    try {
+      const result = await runColdStartQuery({
+        plugin: this.plugin,
+        systemPrompt: TITLE_GENERATION_SYSTEM_PROMPT,
+        tools: [],
+        model: this.resolveTitleModel(),
+        thinking: { disabled: true },
+        persistSession: false,
+        abortController,
+      }, prompt);
+
+      const title = this.parseTitle(result.text);
+      if (title) {
+        await this.safeCallback(callback, conversationId, { success: true, title });
+      } else {
+        await this.safeCallback(callback, conversationId, {
+          success: false,
+          error: 'Failed to parse title from response',
+        });
+      }
+    } catch (error) {
+      const msg = error instanceof Error ? error.message : 'Unknown error';
+      await this.safeCallback(callback, conversationId, { success: false, error: msg });
+    } finally {
+      this.activeGenerations.delete(conversationId);
+    }
+  }
+
+  cancel(): void {
+    for (const controller of this.activeGenerations.values()) {
+      controller.abort();
+    }
+    this.activeGenerations.clear();
+  }
+
+  private resolveTitleModel(): string {
+    const envVars = parseEnvironmentVariables(
+      this.plugin.getActiveEnvironmentVariables('claude')
+    );
+    const titleModel = this.plugin.settings.titleGenerationModel;
+    if (titleModel && claudeChatUIConfig.ownsModel(
+      titleModel,
+      this.plugin.settings as unknown as Record<string, unknown>,
+    )) {
+      return toClaudeRuntimeModelId(titleModel);
+    }
+
+    return (
+      envVars.ANTHROPIC_DEFAULT_HAIKU_MODEL ||
+      'claude-haiku-4-5'
+    );
+  }
+
+  private truncateText(text: string, maxLength: number): string {
+    if (text.length <= maxLength) return text;
+    return text.substring(0, maxLength) + '...';
+  }
+
+  private parseTitle(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 > 50) {
+      title = title.substring(0, 47) + '...';
+    }
+
+    return title || null;
+  }
+
+  private async safeCallback(
+    callback: TitleGenerationCallback,
+    conversationId: string,
+    result: TitleGenerationResult
+  ): Promise<void> {
+    try {
+      await callback(conversationId, result);
+    } catch {
+      // Silently ignore callback errors
+    }
+  }
+}

package/src/providers/claude/auxiliary/extractAssistantText.ts

@@ -0,0 +1,28 @@
+export function extractAssistantText(
+  message: { type: string; message?: unknown }
+): string {
+  if (message.type !== 'assistant') {
+    return '';
+  }
+
+  const payload = message.message;
+  if (!payload || typeof payload !== 'object' || Array.isArray(payload)) {
+    return '';
+  }
+
+  const content = (payload as { content?: unknown }).content;
+  if (!Array.isArray(content)) {
+    return '';
+  }
+
+  return (content as unknown[])
+    .filter((block): block is { type: 'text'; text: string } => {
+      if (!block || typeof block !== 'object' || Array.isArray(block)) {
+        return false;
+      }
+      const record = block as Record<string, unknown>;
+      return record.type === 'text' && typeof record.text === 'string';
+    })
+    .map((block) => block.text)
+    .join('');
+}

package/src/providers/claude/capabilities.ts

@@ -0,0 +1,17 @@
+import type { ProviderCapabilities } from '../../core/providers/types';
+
+export const CLAUDE_PROVIDER_CAPABILITIES: Readonly<ProviderCapabilities> = Object.freeze({
+  providerId: 'claude',
+  supportsPersistentRuntime: true,
+  supportsNativeHistory: true,
+  supportsPlanMode: true,
+  supportsRewind: true,
+  supportsFork: true,
+  supportsProviderCommands: true,
+  supportsImageAttachments: true,
+  supportsInstructionMode: true,
+  supportsMcpTools: true,
+  supportsTurnSteer: false,
+  reasoningControl: 'effort',
+  planPathPrefix: '/.claude/plans/',
+});

package/src/providers/claude/cli/findClaudeCLIPath.ts

@@ -0,0 +1,261 @@
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+
+import { parsePathEntries, resolveNvmDefaultBin } from '../../../utils/path';
+
+const CLAUDE_CODE_PACKAGE_SEGMENTS = ['node_modules', '@anthropic-ai', 'claude-code'];
+const CLAUDE_CODE_NODE_ENTRYPOINTS = ['cli-wrapper.cjs', 'cli.js'];
+
+function getEnvValue(name: string): string | undefined {
+  return process.env[name];
+}
+
+function dedupePaths(entries: string[]): string[] {
+  const seen = new Set<string>();
+  return entries.filter(entry => {
+    const key = process.platform === 'win32' ? entry.toLowerCase() : entry;
+    if (seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  });
+}
+
+function findFirstExistingPath(entries: string[], candidates: string[]): string | null {
+  for (const dir of entries) {
+    if (!dir) continue;
+    for (const candidate of candidates) {
+      const fullPath = path.join(dir, candidate);
+      if (isExistingFile(fullPath)) {
+        return fullPath;
+      }
+    }
+  }
+  return null;
+}
+
+function isExistingFile(filePath: string): boolean {
+  try {
+    if (fs.existsSync(filePath)) {
+      const stat = fs.statSync(filePath);
+      return stat.isFile();
+    }
+  } catch {
+    // Inaccessible path
+  }
+  return false;
+}
+
+function findClaudeCodeNodeEntrypoint(packageRoot: string): string | null {
+  for (const entrypoint of CLAUDE_CODE_NODE_ENTRYPOINTS) {
+    const candidate = path.join(packageRoot, entrypoint);
+    if (isExistingFile(candidate)) {
+      return candidate;
+    }
+  }
+
+  return null;
+}
+
+function resolveClaudeCodeEntrypointNearPathEntry(entry: string, isWindows: boolean): string | null {
+  const directCandidate = findClaudeCodeNodeEntrypoint(
+    path.join(entry, ...CLAUDE_CODE_PACKAGE_SEGMENTS)
+  );
+  if (directCandidate) {
+    return directCandidate;
+  }
+
+  const baseName = path.basename(entry).toLowerCase();
+  if (baseName === 'bin') {
+    const prefix = path.dirname(entry);
+    const packageParent = isWindows ? prefix : path.join(prefix, 'lib');
+    const candidate = findClaudeCodeNodeEntrypoint(
+      path.join(packageParent, ...CLAUDE_CODE_PACKAGE_SEGMENTS)
+    );
+    if (candidate) {
+      return candidate;
+    }
+  }
+
+  return null;
+}
+
+function resolveClaudeCodeEntrypointFromPathEntries(entries: string[], isWindows: boolean): string | null {
+  for (const entry of entries) {
+    const candidate = resolveClaudeCodeEntrypointNearPathEntry(entry, isWindows);
+    if (candidate) {
+      return candidate;
+    }
+  }
+  return null;
+}
+
+function resolveClaudeFromPathEntries(
+  entries: string[],
+  isWindows: boolean
+): string | null {
+  if (entries.length === 0) {
+    return null;
+  }
+
+  if (!isWindows) {
+    const unixCandidate = findFirstExistingPath(entries, ['claude']);
+    return unixCandidate;
+  }
+
+  const exeCandidate = findFirstExistingPath(entries, ['claude.exe', 'claude']);
+  if (exeCandidate) {
+    return exeCandidate;
+  }
+
+  const packageEntrypoint = resolveClaudeCodeEntrypointFromPathEntries(entries, isWindows);
+  if (packageEntrypoint) {
+    return packageEntrypoint;
+  }
+
+  return null;
+}
+
+function getNpmGlobalPrefix(): string | null {
+  if (process.env.npm_config_prefix) {
+    return process.env.npm_config_prefix;
+  }
+
+  if (process.platform === 'win32') {
+    const appDataNpm = process.env.APPDATA
+      ? path.join(process.env.APPDATA, 'npm')
+      : null;
+    if (appDataNpm && fs.existsSync(appDataNpm)) {
+      return appDataNpm;
+    }
+  }
+
+  return null;
+}
+
+function addClaudeCodeEntrypointPaths(paths: string[], packageParent: string): void {
+  const packageRoot = path.join(packageParent, ...CLAUDE_CODE_PACKAGE_SEGMENTS);
+  for (const entrypoint of CLAUDE_CODE_NODE_ENTRYPOINTS) {
+    paths.push(path.join(packageRoot, entrypoint));
+  }
+}
+
+function getNpmClaudeCodeEntrypointPaths(): string[] {
+  const homeDir = os.homedir();
+  const isWindows = process.platform === 'win32';
+  const entrypointPaths: string[] = [];
+
+  if (isWindows) {
+    addClaudeCodeEntrypointPaths(entrypointPaths, path.join(homeDir, 'AppData', 'Roaming', 'npm'));
+
+    const npmPrefix = getNpmGlobalPrefix();
+    if (npmPrefix) {
+      addClaudeCodeEntrypointPaths(entrypointPaths, npmPrefix);
+    }
+
+    const programFiles = process.env.ProgramFiles || 'C:\\Program Files';
+    const programFilesX86 = process.env['ProgramFiles(x86)'] || 'C:\\Program Files (x86)';
+
+    addClaudeCodeEntrypointPaths(entrypointPaths, path.join(programFiles, 'nodejs', 'node_global'));
+    addClaudeCodeEntrypointPaths(entrypointPaths, path.join(programFilesX86, 'nodejs', 'node_global'));
+    addClaudeCodeEntrypointPaths(entrypointPaths, path.join('D:', 'Program Files', 'nodejs', 'node_global'));
+  } else {
+    addClaudeCodeEntrypointPaths(entrypointPaths, path.join(homeDir, '.npm-global', 'lib'));
+    addClaudeCodeEntrypointPaths(entrypointPaths, '/usr/local/lib');
+    addClaudeCodeEntrypointPaths(entrypointPaths, '/usr/lib');
+
+    if (process.env.npm_config_prefix) {
+      addClaudeCodeEntrypointPaths(entrypointPaths, path.join(process.env.npm_config_prefix, 'lib'));
+    }
+  }
+
+  return entrypointPaths;
+}
+
+export function findClaudeCLIPath(pathValue?: string): string | null {
+  const homeDir = os.homedir();
+  const isWindows = process.platform === 'win32';
+
+  const customEntries = dedupePaths(parsePathEntries(pathValue));
+
+  if (customEntries.length > 0) {
+    const customResolution = resolveClaudeFromPathEntries(customEntries, isWindows);
+    if (customResolution) {
+      return customResolution;
+    }
+  }
+
+  // On Windows, prefer native .exe, then Node-backed package entrypoints. Avoid .cmd fallback
+  // because it requires shell: true and breaks SDK stdio streaming.
+  if (isWindows) {
+    const exePaths: string[] = [
+      path.join(homeDir, '.claude', 'local', 'claude.exe'),
+      path.join(homeDir, 'AppData', 'Local', 'Claude', 'claude.exe'),
+      path.join(process.env.ProgramFiles || 'C:\\Program Files', 'Claude', 'claude.exe'),
+      path.join(process.env['ProgramFiles(x86)'] || 'C:\\Program Files (x86)', 'Claude', 'claude.exe'),
+      path.join(homeDir, '.local', 'bin', 'claude.exe'),
+    ];
+
+    for (const p of exePaths) {
+      if (isExistingFile(p)) {
+        return p;
+      }
+    }
+
+    const packageEntrypointPaths = getNpmClaudeCodeEntrypointPaths();
+    for (const p of packageEntrypointPaths) {
+      if (isExistingFile(p)) {
+        return p;
+      }
+    }
+
+  }
+
+  const commonPaths: string[] = [
+    path.join(homeDir, '.claude', 'local', 'claude'),
+    path.join(homeDir, '.local', 'bin', 'claude'),
+    path.join(homeDir, '.volta', 'bin', 'claude'),
+    path.join(homeDir, '.asdf', 'shims', 'claude'),
+    path.join(homeDir, '.asdf', 'bin', 'claude'),
+    '/usr/local/bin/claude',
+    '/opt/homebrew/bin/claude',
+    path.join(homeDir, 'bin', 'claude'),
+    path.join(homeDir, '.npm-global', 'bin', 'claude'),
+  ];
+
+  const npmPrefix = getNpmGlobalPrefix();
+  if (npmPrefix) {
+    commonPaths.push(path.join(npmPrefix, 'bin', 'claude'));
+  }
+
+  // NVM: resolve default version bin when NVM_BIN env var is not available (GUI apps)
+  const nvmBin = resolveNvmDefaultBin(homeDir);
+  if (nvmBin) {
+    commonPaths.push(path.join(nvmBin, 'claude'));
+  }
+
+  for (const p of commonPaths) {
+    if (isExistingFile(p)) {
+      return p;
+    }
+  }
+
+  if (!isWindows) {
+    const packageEntrypointPaths = getNpmClaudeCodeEntrypointPaths();
+    for (const p of packageEntrypointPaths) {
+      if (isExistingFile(p)) {
+        return p;
+      }
+    }
+  }
+
+  const envEntries = dedupePaths(parsePathEntries(getEnvValue('PATH')));
+  if (envEntries.length > 0) {
+    const envResolution = resolveClaudeFromPathEntries(envEntries, isWindows);
+    if (envResolution) {
+      return envResolution;
+    }
+  }
+
+  return null;
+}

package/src/providers/claude/commands/ClaudeCommandCatalog.ts

@@ -0,0 +1,149 @@
+import type {
+  ProviderCommandCatalog,
+  ProviderCommandDropdownConfig,
+} from '../../../core/providers/commands/ProviderCommandCatalog';
+import type { ProviderCommandEntry } from '../../../core/providers/commands/ProviderCommandEntry';
+import type { SlashCommand } from '../../../core/types';
+import { isSkill } from '../../../utils/slashCommand';
+import type { SkillStorage } from '../storage/SkillStorage';
+import type { SlashCommandStorage } from '../storage/SlashCommandStorage';
+
+function slashCommandToEntry(cmd: SlashCommand): ProviderCommandEntry {
+  const skill = isSkill(cmd);
+  return {
+    id: cmd.id,
+    providerId: 'claude',
+    kind: skill ? 'skill' : 'command',
+    name: cmd.name,
+    description: cmd.description,
+    content: cmd.content,
+    argumentHint: cmd.argumentHint,
+    allowedTools: cmd.allowedTools,
+    model: cmd.model,
+    disableModelInvocation: cmd.disableModelInvocation,
+    userInvocable: cmd.userInvocable,
+    context: cmd.context,
+    agent: cmd.agent,
+    hooks: cmd.hooks,
+    scope: cmd.source === 'sdk' ? 'runtime' : 'vault',
+    source: cmd.source ?? 'user',
+    isEditable: cmd.source !== 'sdk',
+    isDeletable: cmd.source !== 'sdk',
+    displayPrefix: '/',
+    insertPrefix: '/',
+  };
+}
+
+function entryToSlashCommand(entry: ProviderCommandEntry): SlashCommand {
+  return {
+    id: entry.id,
+    name: entry.name,
+    description: entry.description,
+    content: entry.content,
+    argumentHint: entry.argumentHint,
+    allowedTools: entry.allowedTools,
+    model: entry.model,
+    disableModelInvocation: entry.disableModelInvocation,
+    userInvocable: entry.userInvocable,
+    context: entry.context,
+    agent: entry.agent,
+    hooks: entry.hooks,
+    source: entry.source,
+    kind: entry.kind,
+  };
+}
+
+// SDK built-in skills that have no meaning inside Claudian
+const BUILTIN_HIDDEN_COMMANDS = new Set([
+  'context', 'cost', 'debug', 'extra-usage', 'heapdump', 'init',
+  'insights', 'loop', 'schedule', 'security-review', 'simplify', 'update-config',
+]);
+
+export type CommandProbe = () => Promise<SlashCommand[]>;
+
+export class ClaudeCommandCatalog implements ProviderCommandCatalog {
+  private sdkCommands: SlashCommand[] = [];
+  private probePromise: Promise<void> | null = null;
+
+  constructor(
+    private commandStorage: SlashCommandStorage,
+    private skillStorage: SkillStorage,
+    private probe?: CommandProbe,
+  ) {}
+
+  setRuntimeCommands(commands: SlashCommand[]): void {
+    this.sdkCommands = commands;
+  }
+
+  async listDropdownEntries(context: { includeBuiltIns: boolean }): Promise<ProviderCommandEntry[]> {
+    void context;
+    // SDK commands already include vault commands/skills (the SDK scans
+    // .claude/commands/ and .claude/skills/ internally). No file scan needed.
+    // When the cache is empty (cold start, no active runtime), probe the SDK.
+    if (this.sdkCommands.length === 0 && this.probe) {
+      await this.ensureProbed();
+    }
+    const runtimeEntries = this.sdkCommands
+      .filter(cmd => !BUILTIN_HIDDEN_COMMANDS.has(cmd.name.toLowerCase()))
+      .map(slashCommandToEntry);
+    if (runtimeEntries.length > 0) {
+      return runtimeEntries;
+    }
+    return this.listVaultEntries();
+  }
+
+  /** Probe the SDK for commands. Deduplicates concurrent calls. */
+  private async ensureProbed(): Promise<void> {
+    if (!this.probe) return;
+    if (!this.probePromise) {
+      this.probePromise = this.probe().then((commands) => {
+        // Only apply probe results if the runtime hasn't provided fresher data
+        if (this.sdkCommands.length === 0 && commands.length > 0) {
+          this.sdkCommands = commands;
+        }
+      }).catch(() => {
+        // Probe is best-effort
+      }).finally(() => {
+        this.probePromise = null;
+      });
+    }
+    await this.probePromise;
+  }
+
+  async listVaultEntries(): Promise<ProviderCommandEntry[]> {
+    const commands = await this.commandStorage.loadAll();
+    const skills = await this.skillStorage.loadAll();
+    return [...commands, ...skills].map(slashCommandToEntry);
+  }
+
+  async saveVaultEntry(entry: ProviderCommandEntry): Promise<void> {
+    const cmd = entryToSlashCommand(entry);
+    if (entry.kind === 'skill') {
+      await this.skillStorage.save(cmd);
+    } else {
+      await this.commandStorage.save(cmd);
+    }
+  }
+
+  async deleteVaultEntry(entry: ProviderCommandEntry): Promise<void> {
+    if (entry.kind === 'skill') {
+      await this.skillStorage.delete(entry.id);
+    } else {
+      await this.commandStorage.delete(entry.id);
+    }
+  }
+
+  getDropdownConfig(): ProviderCommandDropdownConfig {
+    return {
+      providerId: 'claude',
+      triggerChars: ['/'],
+      builtInPrefix: '/',
+      skillPrefix: '/',
+      commandPrefix: '/',
+    };
+  }
+
+  async refresh(): Promise<void> {
+    // Claude revalidation happens externally via setRuntimeCommands
+  }
+}

package/src/providers/claude/commands/probeRuntimeCommands.ts

@@ -0,0 +1,86 @@
+import type { SlashCommand as SDKSlashCommand } from '@anthropic-ai/claude-agent-sdk';
+import { query as agentQuery } from '@anthropic-ai/claude-agent-sdk';
+
+import type { SlashCommand } from '../../../core/types';
+import type ClaudianPlugin from '../../../main';
+import { getEnhancedPath, parseEnvironmentVariables } from '../../../utils/env';
+import { getVaultPath } from '../../../utils/path';
+import { createCustomSpawnFunction } from '../runtime/customSpawn';
+import {
+  getClaudeProviderSettings,
+  resolveClaudeSettingSources,
+} from '../settings';
+
+function mapSdkCommands(sdkCommands: SDKSlashCommand[]): SlashCommand[] {
+  return sdkCommands.map((cmd) => ({
+    id: `sdk:${cmd.name}`,
+    name: cmd.name,
+    description: cmd.description,
+    argumentHint: cmd.argumentHint,
+    content: '',
+    source: 'sdk' as const,
+  }));
+}
+
+/**
+ * Probes the Claude SDK locally to discover available commands and skills.
+ *
+ * Fires a throwaway query with an empty prompt — the SDK emits a system/init
+ * event from local config parsing alone (no API call, no cost). The probe
+ * captures that event, calls supportedCommands() for full metadata, then aborts.
+ */
+export async function probeRuntimeCommands(plugin: ClaudianPlugin): Promise<SlashCommand[]> {
+  const vaultPath = getVaultPath(plugin.app);
+  if (!vaultPath) return [];
+
+  const cliPath = plugin.getResolvedProviderCliPath('claude');
+  if (!cliPath) return [];
+
+  const customEnv = parseEnvironmentVariables(
+    plugin.getActiveEnvironmentVariables('claude')
+  );
+  const enhancedPath = getEnhancedPath(customEnv.PATH, cliPath);
+  const claudeSettings = getClaudeProviderSettings(
+    plugin.settings,
+  );
+
+  const abortController = new AbortController();
+  let commands: SlashCommand[] = [];
+  const extraArgs = {
+    ...(claudeSettings.safeMode === 'auto' ? { 'enable-auto-mode': null } : {}),
+    ...(claudeSettings.enableChrome ? { chrome: null } : {}),
+  };
+
+  try {
+    const conversation = agentQuery({
+      prompt: '',
+      options: {
+        cwd: vaultPath,
+        abortController,
+        pathToClaudeCodeExecutable: cliPath,
+        env: { ...process.env, ...customEnv, PATH: enhancedPath },
+        permissionMode: 'bypassPermissions',
+        allowDangerouslySkipPermissions: true,
+        settingSources: resolveClaudeSettingSources(claudeSettings.loadUserSettings),
+        ...(Object.keys(extraArgs).length > 0 ? { extraArgs } : {}),
+        spawnClaudeCodeProcess: createCustomSpawnFunction(enhancedPath),
+        persistSession: false,
+      },
+    });
+
+    for await (const event of conversation) {
+      if (event.type === 'system' && event.subtype === 'init') {
+        try {
+          const sdkCommands: SDKSlashCommand[] = await conversation.supportedCommands();
+          commands = mapSdkCommands(sdkCommands);
+        } catch { /* best-effort */ }
+        abortController.abort();
+        break;
+      }
+    }
+  } catch {
+    // Probe is best-effort; swallow abort errors.
+  }
+
+  return commands;
+}