@mseep/claudian 2.0.25

package/src/providers/claude/history/sdkSubagentSidecar.ts

@@ -0,0 +1,261 @@
+import { existsSync } from 'fs';
+import * as fs from 'fs/promises';
+import * as path from 'path';
+
+import type { ToolCallInfo } from '../../../core/types';
+import { extractFinalResultFromSubagentJsonl } from '../../../utils/subagentJsonl';
+import { extractToolResultContent } from '../sdk/toolResultContent';
+import type { SDKNativeMessage } from './sdkHistoryTypes';
+import {
+  encodeVaultPathForSDK,
+  getSDKProjectsPath,
+  isPathSafeId,
+  isValidSessionId,
+} from './sdkSessionPaths';
+
+export function isValidAgentId(agentId: string): boolean {
+  return isPathSafeId(agentId);
+}
+
+type SubagentToolEvent =
+  | {
+      type: 'tool_use';
+      toolUseId: string;
+      toolName: string;
+      toolInput: Record<string, unknown>;
+      timestamp: number;
+    }
+  | {
+      type: 'tool_result';
+      toolUseId: string;
+      content: string;
+      isError: boolean;
+      timestamp: number;
+    };
+
+function parseTimestampMs(raw: unknown): number {
+  if (typeof raw !== 'string') {
+    return Date.now();
+  }
+
+  const parsed = Date.parse(raw);
+  return Number.isNaN(parsed) ? Date.now() : parsed;
+}
+
+function parseSubagentEvents(entry: unknown): SubagentToolEvent[] {
+  if (!entry || typeof entry !== 'object') {
+    return [];
+  }
+
+  const record = entry as SDKNativeMessage;
+  const content = record.message?.content;
+  if (!Array.isArray(content)) {
+    return [];
+  }
+
+  const timestamp = parseTimestampMs(record.timestamp);
+  const events: SubagentToolEvent[] = [];
+
+  for (const blockRaw of content) {
+    if (!blockRaw || typeof blockRaw !== 'object') {
+      continue;
+    }
+
+    const block = blockRaw as {
+      type?: unknown;
+      id?: unknown;
+      name?: unknown;
+      input?: unknown;
+      tool_use_id?: unknown;
+      content?: unknown;
+      is_error?: unknown;
+    };
+
+    if (block.type === 'tool_use') {
+      if (typeof block.id !== 'string' || typeof block.name !== 'string') {
+        continue;
+      }
+
+      events.push({
+        type: 'tool_use',
+        toolUseId: block.id,
+        toolName: block.name,
+        toolInput: block.input && typeof block.input === 'object'
+          ? (block.input as Record<string, unknown>)
+          : {},
+        timestamp,
+      });
+      continue;
+    }
+
+    if (block.type === 'tool_result') {
+      if (typeof block.tool_use_id !== 'string') {
+        continue;
+      }
+
+      events.push({
+        type: 'tool_result',
+        toolUseId: block.tool_use_id,
+        content: extractToolResultContent(block.content),
+        isError: block.is_error === true,
+        timestamp,
+      });
+    }
+  }
+
+  return events;
+}
+
+function buildToolCallsFromSubagentEvents(events: SubagentToolEvent[]): ToolCallInfo[] {
+  const toolsById = new Map<
+    string,
+    {
+      toolCall: ToolCallInfo;
+      hasToolUse: boolean;
+      hasToolResult: boolean;
+      timestamp: number;
+    }
+  >();
+
+  for (const event of events) {
+    const existing = toolsById.get(event.toolUseId);
+
+    if (event.type === 'tool_use') {
+      if (!existing) {
+        toolsById.set(event.toolUseId, {
+          toolCall: {
+            id: event.toolUseId,
+            name: event.toolName,
+            input: { ...event.toolInput },
+            status: 'running',
+            isExpanded: false,
+          },
+          hasToolUse: true,
+          hasToolResult: false,
+          timestamp: event.timestamp,
+        });
+      } else {
+        existing.toolCall.name = event.toolName;
+        existing.toolCall.input = { ...event.toolInput };
+        existing.hasToolUse = true;
+        existing.timestamp = event.timestamp;
+      }
+      continue;
+    }
+
+    if (!existing) {
+      toolsById.set(event.toolUseId, {
+        toolCall: {
+          id: event.toolUseId,
+          name: 'Unknown',
+          input: {},
+          status: event.isError ? 'error' : 'completed',
+          result: event.content,
+          isExpanded: false,
+        },
+        hasToolUse: false,
+        hasToolResult: true,
+        timestamp: event.timestamp,
+      });
+      continue;
+    }
+
+    existing.toolCall.status = event.isError ? 'error' : 'completed';
+    existing.toolCall.result = event.content;
+    existing.hasToolResult = true;
+  }
+
+  return Array.from(toolsById.values())
+    .filter(entry => entry.hasToolUse)
+    .sort((a, b) => a.timestamp - b.timestamp)
+    .map(entry => entry.toolCall);
+}
+
+function getSubagentSidecarPath(
+  vaultPath: string,
+  sessionId: string,
+  agentId: string,
+): string | null {
+  if (!isValidSessionId(sessionId) || !isValidAgentId(agentId)) {
+    return null;
+  }
+
+  const encodedVault = encodeVaultPathForSDK(vaultPath);
+  return path.join(
+    getSDKProjectsPath(),
+    encodedVault,
+    sessionId,
+    'subagents',
+    `agent-${agentId}.jsonl`,
+  );
+}
+
+export async function loadSubagentToolCalls(
+  vaultPath: string,
+  sessionId: string,
+  agentId: string,
+): Promise<ToolCallInfo[]> {
+  const subagentFilePath = getSubagentSidecarPath(vaultPath, sessionId, agentId);
+  if (!subagentFilePath) {
+    return [];
+  }
+
+  try {
+    if (!existsSync(subagentFilePath)) {
+      return [];
+    }
+
+    const content = await fs.readFile(subagentFilePath, 'utf-8');
+    const lines = content.split('\n').filter(line => line.trim());
+    const events: SubagentToolEvent[] = [];
+    const seen = new Set<string>();
+
+    for (const line of lines) {
+      let raw: unknown;
+      try {
+        raw = JSON.parse(line);
+      } catch {
+        continue;
+      }
+
+      for (const event of parseSubagentEvents(raw)) {
+        const key = `${event.type}:${event.toolUseId}`;
+        if (seen.has(key)) {
+          continue;
+        }
+        seen.add(key);
+        events.push(event);
+      }
+    }
+
+    if (events.length === 0) {
+      return [];
+    }
+
+    return buildToolCallsFromSubagentEvents(events);
+  } catch {
+    return [];
+  }
+}
+
+export async function loadSubagentFinalResult(
+  vaultPath: string,
+  sessionId: string,
+  agentId: string,
+): Promise<string | null> {
+  const subagentFilePath = getSubagentSidecarPath(vaultPath, sessionId, agentId);
+  if (!subagentFilePath) {
+    return null;
+  }
+
+  try {
+    if (!existsSync(subagentFilePath)) {
+      return null;
+    }
+
+    const content = await fs.readFile(subagentFilePath, 'utf-8');
+    return extractFinalResultFromSubagentJsonl(content);
+  } catch {
+    return null;
+  }
+}

package/src/providers/claude/hooks/SubagentHooks.ts

@@ -0,0 +1,31 @@
+import type { HookCallbackMatcher } from '@anthropic-ai/claude-agent-sdk';
+
+import type { SubagentRuntimeState } from '../../../core/runtime/types';
+
+export type SubagentHookState = SubagentRuntimeState;
+
+const STOP_BLOCK_REASON = 'Background subagents are still running. Use `TaskOutput task_id="..." block=true` to wait for their results before ending your turn.';
+
+export function createStopSubagentHook(
+  getState: () => SubagentHookState
+): HookCallbackMatcher {
+  return {
+    hooks: [
+      async () => {
+        let hasRunning: boolean;
+        try {
+          hasRunning = getState().hasRunning;
+        } catch {
+          // Provider failed — assume subagents are running to be safe
+          hasRunning = true;
+        }
+
+        if (hasRunning) {
+          return { decision: 'block' as const, reason: STOP_BLOCK_REASON };
+        }
+
+        return {};
+      },
+    ],
+  };
+}

package/src/providers/claude/modelLabels.ts

@@ -0,0 +1,77 @@
+function getFamilyDisplayName(family: string): string {
+  return family.charAt(0).toUpperCase() + family.slice(1).toLowerCase();
+}
+
+function formatClaudeModelDateTag(date: string | undefined): string | null {
+  if (!date || date.length < 6) {
+    return null;
+  }
+
+  return `(${date.slice(2, 6)})`;
+}
+
+function getCustomModelLabelSource(modelId: string): string {
+  if (!modelId.includes('/')) {
+    return modelId;
+  }
+
+  return modelId.split('/').pop() || modelId;
+}
+
+function formatGenericCustomModelLabel(labelSource: string): string {
+  return labelSource
+    .replace(/-/g, ' ')
+    .replace(/\b\w/g, letter => letter.toUpperCase());
+}
+
+/**
+ * Formats a custom model ID for display. Prefers the Claude-aware label
+ * (e.g. `Sonnet 4.5`); falls back to the slug tail for namespaced IDs
+ * (`vendor/model`) or a Title Cased version of the raw ID.
+ */
+export function formatCustomModelLabel(modelId: string): string {
+  const labelSource = getCustomModelLabelSource(modelId);
+  const claudeLabel = formatClaudeCustomModelLabel(labelSource);
+  if (claudeLabel) {
+    return claudeLabel;
+  }
+  return modelId.includes('/') ? labelSource : formatGenericCustomModelLabel(labelSource);
+}
+
+function formatClaudeCustomModelLabel(labelSource: string): string | null {
+  const trimmed = labelSource.trim();
+  if (!trimmed) {
+    return null;
+  }
+
+  const is1M = trimmed.toLowerCase().endsWith('[1m]');
+  const without1M = is1M ? trimmed.slice(0, -4) : trimmed;
+  const claudePrefixIndex = without1M.toLowerCase().indexOf('claude-');
+  const candidate = claudePrefixIndex >= 0 ? without1M.slice(claudePrefixIndex) : without1M;
+
+  const versionedMatch = candidate.match(
+    /^claude-(haiku|sonnet|opus)-(\d+)-(\d+)(?:-(\d{8}))?(?:-v\d+:\d+)?$/i,
+  );
+  if (versionedMatch) {
+    const [, family, major, minor, date] = versionedMatch;
+    const suffixes = [
+      formatClaudeModelDateTag(date),
+      is1M ? '(1M)' : null,
+    ].filter(Boolean).join(' ');
+    return `${getFamilyDisplayName(family)} ${major}.${minor}${suffixes ? ` ${suffixes}` : ''}`;
+  }
+
+  const majorOnlyMatch = candidate.match(
+    /^claude-(haiku|sonnet|opus)-(\d+)(?:-(\d{8}))?(?:-v\d+:\d+)?$/i,
+  );
+  if (majorOnlyMatch) {
+    const [, family, major, date] = majorOnlyMatch;
+    const suffixes = [
+      formatClaudeModelDateTag(date),
+      is1M ? '(1M)' : null,
+    ].filter(Boolean).join(' ');
+    return `${getFamilyDisplayName(family)} ${major}${suffixes ? ` ${suffixes}` : ''}`;
+  }
+
+  return null;
+}

package/src/providers/claude/modelOptions.ts

@@ -0,0 +1,113 @@
+import { getRuntimeEnvironmentVariables } from '../../core/providers/providerEnvironment';
+import type { ProviderUIOption } from '../../core/providers/types';
+import { getModelsFromEnvironment } from './env/claudeModelEnv';
+import { formatCustomModelLabel } from './modelLabels';
+import { encodeClaudeModelSelectionId, toClaudeRuntimeModelId } from './modelSelection';
+import { getClaudeProviderSettings } from './settings';
+import { DEFAULT_CLAUDE_MODELS, filterVisibleModelOptions } from './types/models';
+
+function parseConfiguredCustomModelIds(value: string): string[] {
+  const modelIds: string[] = [];
+  const seen = new Set<string>();
+
+  for (const line of value.split(/\r?\n/)) {
+    const modelId = line.trim();
+    if (!modelId || seen.has(modelId)) {
+      continue;
+    }
+    seen.add(modelId);
+    modelIds.push(modelId);
+  }
+
+  return modelIds;
+}
+
+function normalizeCustomModelAliases(value: unknown): Record<string, string> {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) {
+    return {};
+  }
+
+  const aliases: Record<string, string> = {};
+  for (const [rawModelId, rawAlias] of Object.entries(value)) {
+    if (typeof rawAlias !== 'string') {
+      continue;
+    }
+
+    const modelId = rawModelId.trim();
+    const alias = rawAlias.trim();
+    if (modelId && alias) {
+      aliases[modelId] = alias;
+    }
+  }
+
+  return aliases;
+}
+
+export function getClaudeModelOptions(settings: Record<string, unknown>): ProviderUIOption[] {
+  const customModelAliases = normalizeCustomModelAliases(settings.customModelAliases);
+  const customModels = getModelsFromEnvironment(
+    getRuntimeEnvironmentVariables(settings, 'claude'),
+    customModelAliases,
+  );
+  if (customModels.length > 0) {
+    return customModels.map((model) => ({
+      ...model,
+      value: encodeClaudeModelSelectionId(model.value),
+    }));
+  }
+
+  const claudeSettings = getClaudeProviderSettings(settings);
+  const models = filterVisibleModelOptions(
+    [...DEFAULT_CLAUDE_MODELS],
+    claudeSettings.enableOpus1M,
+    claudeSettings.enableSonnet1M,
+  );
+
+  const seenModelIds = new Set(models.map(model => toClaudeRuntimeModelId(model.value)));
+  for (const configuredModelId of parseConfiguredCustomModelIds(claudeSettings.customModels)) {
+    const modelId = toClaudeRuntimeModelId(configuredModelId);
+    if (seenModelIds.has(modelId)) {
+      continue;
+    }
+
+    seenModelIds.add(modelId);
+    models.push({
+      value: encodeClaudeModelSelectionId(modelId),
+      label: customModelAliases[modelId] ?? formatCustomModelLabel(modelId),
+      description: 'Custom model',
+    });
+  }
+
+  return models;
+}
+
+export function resolveClaudeModelSelection(
+  settings: Record<string, unknown>,
+  currentModel: string,
+): string | null {
+  const modelOptions = getClaudeModelOptions(settings);
+  if (currentModel) {
+    const currentRuntimeModel = toClaudeRuntimeModelId(currentModel);
+    const currentOption = modelOptions.find(option =>
+      option.value === currentModel
+      || toClaudeRuntimeModelId(option.value) === currentRuntimeModel
+    );
+    if (currentOption) {
+      return currentOption.value;
+    }
+  }
+
+  const lastModel = getClaudeProviderSettings(settings).lastModel;
+  if (lastModel) {
+    const lastRuntimeModel = toClaudeRuntimeModelId(lastModel);
+    const lastOption = modelOptions.find(option =>
+      option.value === lastModel
+      || toClaudeRuntimeModelId(option.value) === lastRuntimeModel
+    );
+    if (lastOption) {
+      return lastOption.value;
+    }
+  }
+
+  return modelOptions[0]?.value ?? null;
+}

package/src/providers/claude/modelSelection.ts

@@ -0,0 +1,17 @@
+import {
+  encodeProviderModelSelectionId,
+  isProviderModelSelectionId,
+  toProviderRuntimeModelId,
+} from '../../core/providers/modelSelection';
+
+export function encodeClaudeModelSelectionId(modelId: string): string {
+  return encodeProviderModelSelectionId('claude', modelId);
+}
+
+export function isClaudeModelSelectionId(modelId: string): boolean {
+  return isProviderModelSelectionId('claude', modelId);
+}
+
+export function toClaudeRuntimeModelId(modelId: string): string {
+  return toProviderRuntimeModelId('claude', modelId);
+}

package/src/providers/claude/plugins/PluginManager.ts

@@ -0,0 +1,194 @@
+/**
+ * PluginManager - Discover and manage Claude Code plugins.
+ *
+ * Plugins are discovered from two sources:
+ * - installed_plugins.json: install paths for scanning agents
+ * - settings.json: enabled state (project overrides global)
+ */
+
+import * as fs from 'fs';
+import { Notice } from 'obsidian';
+import * as os from 'os';
+import * as path from 'path';
+
+import type { PluginInfo, PluginScope } from '../../../core/types';
+import type { CCSettingsStorage } from '../storage/CCSettingsStorage';
+import type { InstalledPluginEntry, InstalledPluginsFile } from '../types/plugins';
+
+const INSTALLED_PLUGINS_PATH = path.join(os.homedir(), '.claude', 'plugins', 'installed_plugins.json');
+const GLOBAL_SETTINGS_PATH = path.join(os.homedir(), '.claude', 'settings.json');
+
+interface SettingsFile {
+  enabledPlugins?: Record<string, boolean>;
+}
+
+function readJsonFile<T>(filePath: string): T | null {
+  try {
+    if (!fs.existsSync(filePath)) {
+      return null;
+    }
+    const content = fs.readFileSync(filePath, 'utf-8');
+    return JSON.parse(content) as T;
+  } catch {
+    return null;
+  }
+}
+
+function normalizePathForComparison(p: string): string {
+  try {
+    const resolved = fs.realpathSync(p);
+    if (typeof resolved === 'string' && resolved.length > 0) {
+      return resolved;
+    }
+  } catch {
+    // ignore
+  }
+
+  return path.resolve(p);
+}
+
+function selectInstalledPluginEntry(
+  entries: InstalledPluginEntry[],
+  normalizedVaultPath: string
+): InstalledPluginEntry | null {
+  for (const entry of entries) {
+    if (entry.scope !== 'project') continue;
+    if (!entry.projectPath) continue;
+    if (normalizePathForComparison(entry.projectPath) === normalizedVaultPath) {
+      return entry;
+    }
+  }
+
+  return entries.find(e => e.scope === 'user') ?? null;
+}
+
+function extractPluginName(pluginId: string): string {
+  const atIndex = pluginId.indexOf('@');
+  if (atIndex > 0) {
+    return pluginId.substring(0, atIndex);
+  }
+  return pluginId;
+}
+
+export class PluginManager {
+  private ccSettingsStorage: CCSettingsStorage;
+  private vaultPath: string;
+  private plugins: PluginInfo[] = [];
+
+  constructor(vaultPath: string, ccSettingsStorage: CCSettingsStorage) {
+    this.vaultPath = vaultPath;
+    this.ccSettingsStorage = ccSettingsStorage;
+  }
+
+  async loadPlugins(): Promise<void> {
+    const installedPlugins = readJsonFile<InstalledPluginsFile>(INSTALLED_PLUGINS_PATH);
+    const globalSettings = readJsonFile<SettingsFile>(GLOBAL_SETTINGS_PATH);
+    const projectSettings = await this.loadProjectSettings();
+
+    const globalEnabled = globalSettings?.enabledPlugins ?? {};
+    const projectEnabled = projectSettings?.enabledPlugins ?? {};
+
+    const plugins: PluginInfo[] = [];
+    const normalizedVaultPath = normalizePathForComparison(this.vaultPath);
+
+    if (installedPlugins?.plugins) {
+      for (const [pluginId, entries] of Object.entries(installedPlugins.plugins)) {
+        if (!entries || entries.length === 0) continue;
+
+        const entriesArray = Array.isArray(entries) ? entries : [entries];
+        if (!Array.isArray(entries)) {
+          new Notice(`Claudian: plugin "${pluginId}" has malformed entry in installed_plugins.json (expected array, got ${typeof entries})`);
+        }
+        const entry = selectInstalledPluginEntry(entriesArray, normalizedVaultPath);
+        if (!entry) continue;
+
+        const scope: PluginScope = entry.scope === 'project' ? 'project' : 'user';
+
+        // Project setting takes precedence, then global, then default enabled
+        const enabled = projectEnabled[pluginId] ?? globalEnabled[pluginId] ?? true;
+
+        plugins.push({
+          id: pluginId,
+          name: extractPluginName(pluginId),
+          enabled,
+          scope,
+          installPath: entry.installPath,
+        });
+      }
+    }
+
+    this.plugins = plugins.sort((a, b) => {
+      if (a.scope !== b.scope) {
+        return a.scope === 'project' ? -1 : 1;
+      }
+      return a.id.localeCompare(b.id);
+    });
+  }
+
+  private async loadProjectSettings(): Promise<SettingsFile | null> {
+    const projectSettingsPath = path.join(this.vaultPath, '.claude', 'settings.json');
+    return readJsonFile(projectSettingsPath);
+  }
+
+  getPlugins(): PluginInfo[] {
+    return [...this.plugins];
+  }
+
+  hasPlugins(): boolean {
+    return this.plugins.length > 0;
+  }
+
+  hasEnabledPlugins(): boolean {
+    return this.plugins.some((p) => p.enabled);
+  }
+
+  getEnabledCount(): number {
+    return this.plugins.filter((p) => p.enabled).length;
+  }
+
+  /** Used to detect changes that require restarting the persistent query. */
+  getPluginsKey(): string {
+    const enabledPlugins = this.plugins
+      .filter((p) => p.enabled)
+      .sort((a, b) => a.id.localeCompare(b.id));
+
+    if (enabledPlugins.length === 0) {
+      return '';
+    }
+
+    return enabledPlugins.map((p) => `${p.id}:${p.installPath}`).join('|');
+  }
+
+  /** Writes to project .claude/settings.json so CLI respects the state. */
+  async togglePlugin(pluginId: string): Promise<void> {
+    const plugin = this.plugins.find((p) => p.id === pluginId);
+    if (!plugin) {
+      return;
+    }
+
+    const newEnabled = !plugin.enabled;
+    plugin.enabled = newEnabled;
+
+    await this.ccSettingsStorage.setPluginEnabled(pluginId, newEnabled);
+  }
+
+  async enablePlugin(pluginId: string): Promise<void> {
+    const plugin = this.plugins.find((p) => p.id === pluginId);
+    if (!plugin || plugin.enabled) {
+      return;
+    }
+
+    plugin.enabled = true;
+    await this.ccSettingsStorage.setPluginEnabled(pluginId, true);
+  }
+
+  async disablePlugin(pluginId: string): Promise<void> {
+    const plugin = this.plugins.find((p) => p.id === pluginId);
+    if (!plugin || !plugin.enabled) {
+      return;
+    }
+
+    plugin.enabled = false;
+    await this.ccSettingsStorage.setPluginEnabled(pluginId, false);
+  }
+}