@mseep/claudian 2.0.25

package/src/providers/claude/agents/AgentManager.ts

@@ -0,0 +1,225 @@
+/**
+ * Agent load order (earlier sources take precedence for duplicate IDs):
+ * 0. Built-in agents: dynamically provided via SDK init message
+ * 1. Plugin agents: {installPath}/agents/*.md (namespaced as plugin-name:agent-name)
+ * 2. Vault agents: {vaultPath}/.claude/agents/*.md
+ * 3. Global agents: ~/.claude/agents/*.md
+ */
+
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+
+import type { AgentDefinition, AgentFrontmatter } from '../../../core/types';
+import type { PluginManager } from '../plugins/PluginManager';
+import { buildAgentFromFrontmatter, parseAgentFile } from './AgentStorage';
+
+const GLOBAL_AGENTS_DIR = path.join(os.homedir(), '.claude', 'agents');
+const VAULT_AGENTS_DIR = '.claude/agents';
+const PLUGIN_AGENTS_DIR = 'agents';
+
+// Fallback built-in agent names for before the init message arrives.
+const FALLBACK_BUILTIN_AGENT_NAMES = ['Explore', 'Plan', 'Bash', 'general-purpose'];
+
+const BUILTIN_AGENT_DESCRIPTIONS: Record<string, string> = {
+  'Explore': 'Fast codebase exploration and search',
+  'Plan': 'Implementation planning and architecture',
+  'Bash': 'Command execution specialist',
+  'general-purpose': 'Multi-step tasks and complex workflows',
+};
+
+function makeBuiltinAgent(name: string): AgentDefinition {
+  return {
+    id: name,
+    name: name.replace(/-/g, ' ').replace(/\b\w/g, l => l.toUpperCase()),
+    description: BUILTIN_AGENT_DESCRIPTIONS[name] ?? '',
+    prompt: '', // Built-in — prompt managed by SDK
+    source: 'builtin',
+  };
+}
+
+function normalizePluginName(name: string): string {
+  return name.toLowerCase().replace(/\s+/g, '-');
+}
+
+export class AgentManager {
+  private agents: AgentDefinition[] = [];
+  private builtinAgentNames: string[] = FALLBACK_BUILTIN_AGENT_NAMES;
+  private vaultPath: string;
+  private pluginManager: PluginManager;
+
+  constructor(vaultPath: string, pluginManager: PluginManager) {
+    this.vaultPath = vaultPath;
+    this.pluginManager = pluginManager;
+  }
+
+  /** Built-in agents are those from init that are NOT loaded from files. */
+  setBuiltinAgentNames(names: string[]): void {
+    this.builtinAgentNames = names;
+    // Rebuild agents to reflect the new built-in list
+    const fileAgentIds = new Set(
+      this.agents.filter(a => a.source !== 'builtin').map(a => a.id)
+    );
+    // Replace built-in entries with updated list
+    this.agents = [
+      ...names.filter(n => !fileAgentIds.has(n)).map(makeBuiltinAgent),
+      ...this.agents.filter(a => a.source !== 'builtin'),
+    ];
+  }
+
+  async loadAgents(): Promise<void> {
+    this.agents = [];
+
+    for (const name of this.builtinAgentNames) {
+      this.addAgent(makeBuiltinAgent(name));
+    }
+
+    try { this.loadPluginAgents(); } catch { /* non-critical */ }
+    try { this.loadVaultAgents(); } catch { /* non-critical */ }
+    try { this.loadGlobalAgents(); } catch { /* non-critical */ }
+  }
+
+  getAvailableAgents(): AgentDefinition[] {
+    return [...this.agents];
+  }
+
+  getAgentById(id: string): AgentDefinition | undefined {
+    return this.agents.find(a => a.id === id);
+  }
+
+  /** Used for @-mention filtering in the chat input. */
+  searchAgents(query: string): AgentDefinition[] {
+    const q = query.toLowerCase();
+    return this.agents.filter(a =>
+      a.name.toLowerCase().includes(q) ||
+      a.id.toLowerCase().includes(q) ||
+      a.description.toLowerCase().includes(q)
+    );
+  }
+
+  private loadPluginAgents(): void {
+    for (const plugin of this.pluginManager.getPlugins()) {
+      if (!plugin.enabled) continue;
+
+      const agentsDir = path.join(plugin.installPath, PLUGIN_AGENTS_DIR);
+      if (!fs.existsSync(agentsDir)) continue;
+
+      this.loadAgentsFromFiles(
+        this.listMarkdownFiles(agentsDir),
+        (filePath) => this.parsePluginAgentFromFile(filePath, plugin.name),
+      );
+    }
+  }
+
+  private loadVaultAgents(): void {
+    this.loadAgentsFromDirectory(path.join(this.vaultPath, VAULT_AGENTS_DIR), 'vault');
+  }
+
+  private loadGlobalAgents(): void {
+    this.loadAgentsFromDirectory(GLOBAL_AGENTS_DIR, 'global');
+  }
+
+  private loadAgentsFromDirectory(
+    dir: string,
+    source: 'vault' | 'global'
+  ): void {
+    if (!fs.existsSync(dir)) return;
+
+    this.loadAgentsFromFiles(
+      this.listMarkdownFiles(dir),
+      (filePath) => this.parseAgentFromFile(filePath, source),
+    );
+  }
+
+  private listMarkdownFiles(dir: string): string[] {
+    const files: string[] = [];
+
+    try {
+      const entries = fs.readdirSync(dir, { withFileTypes: true });
+
+      for (const entry of entries) {
+        if (entry.isFile() && entry.name.endsWith('.md')) {
+          files.push(path.join(dir, entry.name));
+        }
+      }
+    } catch {
+      // Non-critical: directory may be unreadable
+    }
+
+    return files;
+  }
+
+  private parsePluginAgentFromFile(
+    filePath: string,
+    pluginName: string
+  ): AgentDefinition | null {
+    return this.parseAgentDefinition(
+      filePath,
+      (agentName) => `${normalizePluginName(pluginName)}:${agentName}`,
+      (frontmatter, body, id) => buildAgentFromFrontmatter(frontmatter, body, {
+        id,
+        source: 'plugin',
+        pluginName,
+        filePath,
+      }),
+    );
+  }
+
+  private parseAgentFromFile(
+    filePath: string,
+    source: 'vault' | 'global'
+  ): AgentDefinition | null {
+    return this.parseAgentDefinition(
+      filePath,
+      (agentName) => agentName,
+      (frontmatter, body, id) => buildAgentFromFrontmatter(frontmatter, body, {
+        id,
+        source,
+        filePath,
+      }),
+    );
+  }
+
+  private loadAgentsFromFiles(
+    filePaths: string[],
+    loadAgent: (filePath: string) => AgentDefinition | null,
+  ): void {
+    for (const filePath of filePaths) {
+      this.addAgent(loadAgent(filePath));
+    }
+  }
+
+  private addAgent(agent: AgentDefinition | null): void {
+    if (!agent) {
+      return;
+    }
+    if (this.agents.some(existing => existing.id === agent.id)) {
+      return;
+    }
+    this.agents.push(agent);
+  }
+
+  private parseAgentDefinition(
+    filePath: string,
+    buildId: (agentName: string) => string,
+    buildAgent: (
+      frontmatter: AgentFrontmatter,
+      body: string,
+      id: string,
+    ) => AgentDefinition,
+  ): AgentDefinition | null {
+    try {
+      const content = fs.readFileSync(filePath, 'utf-8');
+      const parsed = parseAgentFile(content);
+
+      if (!parsed) {
+        return null;
+      }
+
+      const { frontmatter, body } = parsed;
+      return buildAgent(frontmatter, body, buildId(frontmatter.name));
+    } catch {
+      return null;
+    }
+  }
+}

package/src/providers/claude/agents/AgentStorage.ts

@@ -0,0 +1,101 @@
+import type { AgentDefinition, AgentFrontmatter } from '../../../core/types';
+import { extractStringArray, isRecord, normalizeStringArray, parseFrontmatter } from '../../../utils/frontmatter';
+import { AGENT_PERMISSION_MODES, type AgentPermissionMode } from '../types/agent';
+
+const KNOWN_AGENT_KEYS = new Set([
+  'name', 'description', 'tools', 'disallowedTools', 'model',
+  'skills', 'permissionMode', 'hooks',
+]);
+
+export function parseAgentFile(content: string): { frontmatter: AgentFrontmatter; body: string } | null {
+  const parsed = parseFrontmatter(content);
+  if (!parsed) return null;
+
+  const { frontmatter: fm, body } = parsed;
+
+  const name = fm.name;
+  const description = fm.description;
+
+  if (typeof name !== 'string' || !name.trim()) return null;
+  if (typeof description !== 'string' || !description.trim()) return null;
+
+  const tools = fm.tools;
+  const disallowedTools = fm.disallowedTools;
+
+  if (tools !== undefined && !isStringOrArray(tools)) return null;
+  if (disallowedTools !== undefined && !isStringOrArray(disallowedTools)) return null;
+
+  const model = typeof fm.model === 'string' ? fm.model : undefined;
+
+  const extra: Record<string, unknown> = {};
+  for (const key of Object.keys(fm)) {
+    if (!KNOWN_AGENT_KEYS.has(key)) {
+      extra[key] = fm[key];
+    }
+  }
+
+  const frontmatter: AgentFrontmatter = {
+    name,
+    description,
+    tools,
+    disallowedTools,
+    model,
+    skills: extractStringArray(fm, 'skills'),
+    permissionMode: typeof fm.permissionMode === 'string' ? fm.permissionMode : undefined,
+    hooks: isRecord(fm.hooks) ? fm.hooks : undefined,
+    extraFrontmatter: Object.keys(extra).length > 0 ? extra : undefined,
+  };
+
+  return { frontmatter, body: body.trim() };
+}
+
+function isStringOrArray(value: unknown): value is string | string[] {
+  return typeof value === 'string' || Array.isArray(value);
+}
+
+export function parseToolsList(tools?: string | string[]): string[] | undefined {
+  return normalizeStringArray(tools);
+}
+
+export function parsePermissionMode(mode?: string): AgentPermissionMode | undefined {
+  if (!mode) return undefined;
+  const trimmed = mode.trim();
+  if ((AGENT_PERMISSION_MODES as readonly string[]).includes(trimmed)) {
+    return trimmed as AgentPermissionMode;
+  }
+  return undefined;
+}
+
+const VALID_MODELS = ['sonnet', 'opus', 'haiku', 'inherit'] as const;
+
+export function parseModel(model?: string): 'sonnet' | 'opus' | 'haiku' | 'inherit' {
+  if (!model) return 'inherit';
+  const normalized = model.toLowerCase().trim();
+  if (VALID_MODELS.includes(normalized as typeof VALID_MODELS[number])) {
+    return normalized as 'sonnet' | 'opus' | 'haiku' | 'inherit';
+  }
+  return 'inherit';
+}
+
+export function buildAgentFromFrontmatter(
+  frontmatter: AgentFrontmatter,
+  body: string,
+  meta: { id: string; source: AgentDefinition['source']; filePath?: string; pluginName?: string }
+): AgentDefinition {
+  return {
+    id: meta.id,
+    name: frontmatter.name,
+    description: frontmatter.description,
+    prompt: body,
+    tools: parseToolsList(frontmatter.tools),
+    disallowedTools: parseToolsList(frontmatter.disallowedTools),
+    model: parseModel(frontmatter.model),
+    source: meta.source,
+    filePath: meta.filePath,
+    pluginName: meta.pluginName,
+    skills: frontmatter.skills,
+    permissionMode: parsePermissionMode(frontmatter.permissionMode),
+    hooks: frontmatter.hooks,
+    extraFrontmatter: frontmatter.extraFrontmatter,
+  };
+}

package/src/providers/claude/app/ClaudeWorkspaceServices.ts

@@ -0,0 +1,90 @@
+import { McpServerManager } from '../../../core/mcp/McpServerManager';
+import type { ProviderCommandCatalog } from '../../../core/providers/commands/ProviderCommandCatalog';
+import { ProviderWorkspaceRegistry } from '../../../core/providers/ProviderWorkspaceRegistry';
+import type {
+  AppAgentManager,
+  AppAgentStorage,
+  AppMcpStorage,
+  AppPluginManager,
+  ProviderCliResolver,
+  ProviderWorkspaceRegistration,
+  ProviderWorkspaceServices,
+} from '../../../core/providers/types';
+import type { VaultFileAdapter } from '../../../core/storage/VaultFileAdapter';
+import type ClaudianPlugin from '../../../main';
+import { getVaultPath } from '../../../utils/path';
+import { AgentManager } from '../agents/AgentManager';
+import { ClaudeCommandCatalog } from '../commands/ClaudeCommandCatalog';
+import { probeRuntimeCommands } from '../commands/probeRuntimeCommands';
+import { PluginManager } from '../plugins/PluginManager';
+import { ClaudeCliResolver } from '../runtime/ClaudeCliResolver';
+import { StorageService } from '../storage/StorageService';
+import { claudeSettingsTabRenderer } from '../ui/ClaudeSettingsTab';
+
+export interface ClaudeWorkspaceServices extends ProviderWorkspaceServices {
+  claudeStorage: StorageService;
+  cliResolver: ProviderCliResolver;
+  mcpStorage: AppMcpStorage;
+  mcpManager: McpServerManager;
+  pluginManager: AppPluginManager;
+  agentStorage: AppAgentStorage;
+  agentManager: AppAgentManager;
+  commandCatalog: ProviderCommandCatalog;
+  agentMentionProvider: AppAgentManager;
+}
+
+export async function createClaudeWorkspaceServices(
+  plugin: ClaudianPlugin,
+  adapter: VaultFileAdapter,
+): Promise<ClaudeWorkspaceServices> {
+  const claudeStorage = new StorageService(plugin, adapter);
+  await claudeStorage.ensureDirectories();
+
+  const cliResolver = new ClaudeCliResolver();
+  const mcpStorage = claudeStorage.mcp;
+  const mcpManager = new McpServerManager(mcpStorage);
+  await mcpManager.loadServers();
+
+  const vaultPath = getVaultPath(plugin.app) ?? '';
+  const pluginManager = new PluginManager(vaultPath, claudeStorage.ccSettings);
+  await pluginManager.loadPlugins();
+
+  const agentStorage = claudeStorage.agents;
+  const agentManager = new AgentManager(vaultPath, pluginManager);
+  await agentManager.loadAgents();
+
+  const commandCatalog = new ClaudeCommandCatalog(
+    claudeStorage.commands,
+    claudeStorage.skills,
+    () => probeRuntimeCommands(plugin),
+  );
+
+  return {
+    claudeStorage,
+    cliResolver,
+    mcpStorage,
+    mcpServerManager: mcpManager,
+    mcpManager,
+    pluginManager,
+    agentStorage,
+    agentManager,
+    commandCatalog,
+    agentMentionProvider: agentManager,
+    settingsTabRenderer: claudeSettingsTabRenderer,
+    refreshAgentMentions: async () => {
+      await agentManager.loadAgents();
+    },
+  };
+}
+
+export const claudeWorkspaceRegistration: ProviderWorkspaceRegistration<ClaudeWorkspaceServices> = {
+  initialize: async ({ plugin, vaultAdapter }) => createClaudeWorkspaceServices(plugin, vaultAdapter),
+};
+
+export function maybeGetClaudeWorkspaceServices(): ClaudeWorkspaceServices | null {
+  return ProviderWorkspaceRegistry.getServices('claude') as ClaudeWorkspaceServices | null;
+}
+
+export function getClaudeWorkspaceServices(): ClaudeWorkspaceServices {
+  return ProviderWorkspaceRegistry.requireServices('claude') as ClaudeWorkspaceServices;
+}

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

@@ -0,0 +1,122 @@
+import type { HookCallbackMatcher } from '@anthropic-ai/claude-agent-sdk';
+
+import {
+  buildInlineEditPrompt,
+  getInlineEditSystemPrompt,
+  parseInlineEditResponse,
+} from '../../../core/prompt/inlineEdit';
+import { ProviderSettingsCoordinator } from '../../../core/providers/ProviderSettingsCoordinator';
+import type {
+  InlineEditRequest,
+  InlineEditResult,
+} from '../../../core/providers/types';
+import {
+  isReadOnlyTool,
+  READ_ONLY_TOOLS,
+} from '../../../core/tools/toolNames';
+import type ClaudianPlugin from '../../../main';
+import { appendContextFiles } from '../../../utils/context';
+import { runColdStartQuery } from '../runtime/claudeColdStartQuery';
+
+export type { InlineEditRequest };
+
+export function createReadOnlyHook(): HookCallbackMatcher {
+  return {
+    hooks: [
+      async (hookInput) => {
+        const input = hookInput as {
+          tool_name: string;
+          tool_input: Record<string, unknown>;
+        };
+        const toolName = input.tool_name;
+
+        if (isReadOnlyTool(toolName)) {
+          return { continue: true };
+        }
+
+        return {
+          continue: false,
+          hookSpecificOutput: {
+            hookEventName: 'PreToolUse' as const,
+            permissionDecision: 'deny' as const,
+            permissionDecisionReason: `Inline edit mode: tool "${toolName}" is not allowed (read-only)`,
+          },
+        };
+      },
+    ],
+  };
+}
+
+export class InlineEditService {
+  private plugin: ClaudianPlugin;
+  private abortController: AbortController | null = null;
+  private sessionId: string | null = null;
+
+  constructor(plugin: ClaudianPlugin) {
+    this.plugin = plugin;
+  }
+
+  private getScopedSettings(): Record<string, unknown> {
+    return ProviderSettingsCoordinator.getProviderSettingsSnapshot(
+      this.plugin.settings,
+      'claude',
+    );
+  }
+
+  resetConversation(): void {
+    this.sessionId = null;
+  }
+
+  async editText(request: InlineEditRequest): Promise<InlineEditResult> {
+    this.sessionId = null;
+    const prompt = buildInlineEditPrompt(request);
+    return this.sendMessage(prompt);
+  }
+
+  async continueConversation(message: string, contextFiles?: string[]): Promise<InlineEditResult> {
+    if (!this.sessionId) {
+      return { success: false, error: 'No active conversation to continue' };
+    }
+    let prompt = message;
+    if (contextFiles && contextFiles.length > 0) {
+      prompt = appendContextFiles(message, contextFiles);
+    }
+    return this.sendMessage(prompt);
+  }
+
+  private async sendMessage(prompt: string): Promise<InlineEditResult> {
+    const settings = this.getScopedSettings();
+
+    this.abortController = new AbortController();
+
+    const hooks = {
+      PreToolUse: [createReadOnlyHook()],
+    };
+
+    try {
+      const result = await runColdStartQuery({
+        plugin: this.plugin,
+        systemPrompt: getInlineEditSystemPrompt(),
+        tools: [...READ_ONLY_TOOLS],
+        hooks,
+        resumeSessionId: this.sessionId ?? undefined,
+        abortController: this.abortController,
+        providerSettings: settings,
+      }, prompt);
+
+      this.sessionId = result.sessionId;
+      return parseInlineEditResponse(result.text);
+    } catch (error) {
+      const msg = error instanceof Error ? error.message : 'Unknown error';
+      return { success: false, error: msg };
+    } finally {
+      this.abortController = null;
+    }
+  }
+
+  cancel(): void {
+    if (this.abortController) {
+      this.abortController.abort();
+    }
+  }
+}

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

@@ -0,0 +1,90 @@
+import { buildRefineSystemPrompt } from '../../../core/prompt/instructionRefine';
+import type { RefineProgressCallback } from '../../../core/providers/types';
+import type { InstructionRefineResult } from '../../../core/types';
+import type ClaudianPlugin from '../../../main';
+import { runColdStartQuery } from '../runtime/claudeColdStartQuery';
+
+export class InstructionRefineService {
+  private plugin: ClaudianPlugin;
+  private abortController: AbortController | null = null;
+  private sessionId: string | null = null;
+  private existingInstructions: string = '';
+
+  constructor(plugin: ClaudianPlugin) {
+    this.plugin = plugin;
+  }
+
+  resetConversation(): void {
+    this.sessionId = null;
+  }
+
+  async refineInstruction(
+    rawInstruction: string,
+    existingInstructions: string,
+    onProgress?: RefineProgressCallback
+  ): Promise<InstructionRefineResult> {
+    this.sessionId = null;
+    this.existingInstructions = existingInstructions;
+    const prompt = `Please refine this instruction: "${rawInstruction}"`;
+    return this.sendMessage(prompt, onProgress);
+  }
+
+  async continueConversation(
+    message: string,
+    onProgress?: RefineProgressCallback
+  ): Promise<InstructionRefineResult> {
+    if (!this.sessionId) {
+      return { success: false, error: 'No active conversation to continue' };
+    }
+    return this.sendMessage(message, onProgress);
+  }
+
+  cancel(): void {
+    if (this.abortController) {
+      this.abortController.abort();
+      this.abortController = null;
+    }
+  }
+
+  private async sendMessage(
+    prompt: string,
+    onProgress?: RefineProgressCallback
+  ): Promise<InstructionRefineResult> {
+    this.abortController = new AbortController();
+
+    try {
+      const result = await runColdStartQuery({
+        plugin: this.plugin,
+        systemPrompt: buildRefineSystemPrompt(this.existingInstructions),
+        tools: [],
+        resumeSessionId: this.sessionId ?? undefined,
+        abortController: this.abortController,
+        onTextChunk: onProgress
+          ? (accumulatedText: string) => onProgress(this.parseResponse(accumulatedText))
+          : undefined,
+      }, prompt);
+
+      this.sessionId = result.sessionId;
+      return this.parseResponse(result.text);
+    } catch (error) {
+      const msg = error instanceof Error ? error.message : 'Unknown error';
+      return { success: false, error: msg };
+    } finally {
+      this.abortController = null;
+    }
+  }
+
+  private parseResponse(responseText: string): InstructionRefineResult {
+    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' };
+  }
+}