mirror of
https://github.com/0xatrilla/AI-Sidebar.git
synced 2026-07-22 06:51:46 +00:00
2021 lines
66 KiB
TypeScript
2021 lines
66 KiB
TypeScript
import {
|
|
App,
|
|
ButtonComponent,
|
|
DropdownComponent,
|
|
ItemView,
|
|
MarkdownView,
|
|
Modal,
|
|
Notice,
|
|
Plugin,
|
|
PluginSettingTab,
|
|
requestUrl,
|
|
Setting,
|
|
TFile,
|
|
WorkspaceLeaf,
|
|
} from "obsidian";
|
|
import { spawn } from "child_process";
|
|
import { promises as fs } from "fs";
|
|
import { homedir } from "os";
|
|
import * as path from "path";
|
|
|
|
const VIEW_TYPE_AI_SIDEBAR = "ai-sidebar-view";
|
|
|
|
type AccessMode = "read-only" | "confirm" | "full-access";
|
|
type ProviderAuthType = "api-key" | "oauth" | "cli";
|
|
type ReasoningEffort = "low" | "medium" | "high";
|
|
|
|
interface AgentProvider {
|
|
id: string;
|
|
name: string;
|
|
authType: ProviderAuthType;
|
|
command: string;
|
|
signInCommand?: string;
|
|
setupUrl?: string;
|
|
connectedAt?: number;
|
|
apiBaseUrl?: string;
|
|
apiKey?: string;
|
|
model?: string;
|
|
models?: string;
|
|
reasoningEffort?: ReasoningEffort;
|
|
authorizationUrl?: string;
|
|
tokenUrl?: string;
|
|
clientId?: string;
|
|
scope?: string;
|
|
accessToken?: string;
|
|
refreshToken?: string;
|
|
tokenExpiresAt?: number;
|
|
}
|
|
|
|
interface AISidebarSettings {
|
|
providers: AgentProvider[];
|
|
defaultProviderId: string;
|
|
defaultAccessMode: AccessMode;
|
|
includeFolders: string;
|
|
excludeFolders: string;
|
|
maxContextChars: number;
|
|
enableConversationMemory: boolean;
|
|
maxMemoryMessages: number;
|
|
rememberedMessages: ChatMessage[];
|
|
}
|
|
|
|
interface VaultContextFile {
|
|
path: string;
|
|
content: string;
|
|
reason: string;
|
|
}
|
|
|
|
interface AgentSkill {
|
|
name: string;
|
|
path: string;
|
|
content: string;
|
|
}
|
|
|
|
interface SkillReference {
|
|
name: string;
|
|
path: string;
|
|
source: "vault" | "global";
|
|
}
|
|
|
|
interface VaultContext {
|
|
activeFile?: VaultContextFile;
|
|
selection?: string;
|
|
linkedFiles: VaultContextFile[];
|
|
backlinkFiles: VaultContextFile[];
|
|
relevantFiles: VaultContextFile[];
|
|
baseFiles: VaultContextFile[];
|
|
selectedSkills: AgentSkill[];
|
|
}
|
|
|
|
interface ChatMessage {
|
|
role: "user" | "assistant" | "system";
|
|
content: string;
|
|
}
|
|
|
|
interface AgentRequest {
|
|
prompt: string;
|
|
accessMode: AccessMode;
|
|
context: VaultContext;
|
|
instructions: string;
|
|
conversation: ChatMessage[];
|
|
options: AgentRequestOptions;
|
|
}
|
|
|
|
interface AgentRequestOptions {
|
|
model?: string;
|
|
reasoningEffort?: ReasoningEffort;
|
|
memoryEnabled: boolean;
|
|
}
|
|
|
|
interface ParsedPrompt {
|
|
cleanPrompt: string;
|
|
selectedSkillNames: string[];
|
|
options: AgentRequestOptions;
|
|
accessMode?: AccessMode;
|
|
}
|
|
|
|
type VaultAction =
|
|
| { type: "create"; path: string; content: string }
|
|
| { type: "edit"; path: string; content: string }
|
|
| { type: "append"; path: string; content: string }
|
|
| { type: "delete"; path: string }
|
|
| { type: "rename"; path: string; newPath: string };
|
|
|
|
interface ProviderPreset {
|
|
id: string;
|
|
name: string;
|
|
description: string;
|
|
provider: AgentProvider;
|
|
}
|
|
|
|
const PROVIDER_PRESETS: ProviderPreset[] = [
|
|
{
|
|
id: "codex",
|
|
name: "Codex",
|
|
description: "Sign in with Codex locally and use the Codex CLI agent.",
|
|
provider: {
|
|
id: "codex",
|
|
name: "Codex",
|
|
authType: "cli",
|
|
command: "codex exec",
|
|
signInCommand: "codex login",
|
|
models: "gpt-5.4, gpt-5.4-mini, gpt-5.3-codex",
|
|
reasoningEffort: "medium",
|
|
},
|
|
},
|
|
{
|
|
id: "claude",
|
|
name: "Claude Code",
|
|
description: "Sign in with your Claude subscription or Anthropic Console account.",
|
|
provider: {
|
|
id: "claude",
|
|
name: "Claude Code",
|
|
authType: "cli",
|
|
command: "claude",
|
|
signInCommand: "claude auth login",
|
|
setupUrl: "https://code.claude.com/docs/en/cli-usage",
|
|
models: "opus, sonnet, haiku",
|
|
},
|
|
},
|
|
{
|
|
id: "opencode",
|
|
name: "opencode",
|
|
description: "Connect opencode to any provider it supports, including subscription/API accounts.",
|
|
provider: {
|
|
id: "opencode",
|
|
name: "opencode",
|
|
authType: "cli",
|
|
command: "opencode",
|
|
signInCommand: "opencode auth login",
|
|
setupUrl: "https://opencode.ai/docs/cli/",
|
|
models: "anthropic/claude-sonnet-4-5, openai/gpt-5.4, google/gemini-2.5-pro",
|
|
},
|
|
},
|
|
{
|
|
id: "openai",
|
|
name: "OpenAI API",
|
|
description: "Use an OpenAI API key with the Responses API.",
|
|
provider: {
|
|
id: "openai",
|
|
name: "OpenAI",
|
|
authType: "api-key",
|
|
command: "",
|
|
setupUrl: "https://platform.openai.com/api-keys",
|
|
apiBaseUrl: "https://api.openai.com/v1/responses",
|
|
model: "gpt-4.1-mini",
|
|
models: "gpt-4.1-mini, gpt-4.1, o4-mini",
|
|
reasoningEffort: "medium",
|
|
},
|
|
},
|
|
{
|
|
id: "anthropic-api",
|
|
name: "Anthropic API",
|
|
description: "Use an Anthropic API key directly through an OpenAI-compatible proxy endpoint.",
|
|
provider: {
|
|
id: "anthropic-api",
|
|
name: "Anthropic API",
|
|
authType: "api-key",
|
|
command: "",
|
|
setupUrl: "https://console.anthropic.com/settings/keys",
|
|
apiBaseUrl: "",
|
|
model: "claude-sonnet-4-5",
|
|
models: "claude-sonnet-4-5, claude-opus-4-1, claude-haiku-4-5",
|
|
},
|
|
},
|
|
{
|
|
id: "gemini-cli",
|
|
name: "Gemini CLI",
|
|
description: "Use Google Gemini CLI with its native sign-in and subscription/API setup.",
|
|
provider: {
|
|
id: "gemini-cli",
|
|
name: "Gemini CLI",
|
|
authType: "cli",
|
|
command: "gemini",
|
|
signInCommand: "gemini",
|
|
setupUrl: "https://google-gemini.github.io/gemini-cli/docs/",
|
|
models: "gemini-2.5-pro, gemini-2.5-flash",
|
|
},
|
|
},
|
|
{
|
|
id: "openrouter",
|
|
name: "OpenRouter",
|
|
description: "Use one API key for many model providers through an OpenAI-compatible endpoint.",
|
|
provider: {
|
|
id: "openrouter",
|
|
name: "OpenRouter",
|
|
authType: "api-key",
|
|
command: "",
|
|
setupUrl: "https://openrouter.ai/settings/keys",
|
|
apiBaseUrl: "https://openrouter.ai/api/v1/chat/completions",
|
|
model: "openai/gpt-4.1-mini",
|
|
models: "openai/gpt-4.1-mini, anthropic/claude-sonnet-4.5, google/gemini-2.5-pro",
|
|
reasoningEffort: "medium",
|
|
},
|
|
},
|
|
{
|
|
id: "deepseek",
|
|
name: "DeepSeek",
|
|
description: "Use DeepSeek with an API key and OpenAI-compatible endpoint.",
|
|
provider: {
|
|
id: "deepseek",
|
|
name: "DeepSeek",
|
|
authType: "api-key",
|
|
command: "",
|
|
setupUrl: "https://platform.deepseek.com/api_keys",
|
|
apiBaseUrl: "https://api.deepseek.com/v1/chat/completions",
|
|
model: "deepseek-chat",
|
|
models: "deepseek-chat, deepseek-reasoner",
|
|
},
|
|
},
|
|
{
|
|
id: "mistral",
|
|
name: "Mistral",
|
|
description: "Use Mistral models with an API key and OpenAI-compatible endpoint.",
|
|
provider: {
|
|
id: "mistral",
|
|
name: "Mistral",
|
|
authType: "api-key",
|
|
command: "",
|
|
setupUrl: "https://console.mistral.ai/api-keys",
|
|
apiBaseUrl: "https://api.mistral.ai/v1/chat/completions",
|
|
model: "mistral-large-latest",
|
|
models: "mistral-large-latest, codestral-latest, ministral-8b-latest",
|
|
},
|
|
},
|
|
{
|
|
id: "aider",
|
|
name: "Aider",
|
|
description: "Use Aider with keys from OpenAI, Anthropic, Gemini, OpenRouter, DeepSeek, and more.",
|
|
provider: {
|
|
id: "aider",
|
|
name: "Aider",
|
|
authType: "cli",
|
|
command: "aider",
|
|
signInCommand: "aider",
|
|
setupUrl: "https://aider.chat/docs/config/api-keys.html",
|
|
models: "sonnet, opus, gpt-4.1, o4-mini, gemini/gemini-2.5-pro",
|
|
},
|
|
},
|
|
];
|
|
|
|
const DEFAULT_SETTINGS: AISidebarSettings = {
|
|
providers: [
|
|
cloneProvider(PROVIDER_PRESETS[0].provider),
|
|
cloneProvider(PROVIDER_PRESETS[3].provider),
|
|
],
|
|
defaultProviderId: "codex",
|
|
defaultAccessMode: "confirm",
|
|
includeFolders: "",
|
|
excludeFolders: "node_modules, .git",
|
|
maxContextChars: 45000,
|
|
enableConversationMemory: true,
|
|
maxMemoryMessages: 30,
|
|
rememberedMessages: [],
|
|
};
|
|
|
|
export default class AISidebarPlugin extends Plugin {
|
|
settings: AISidebarSettings;
|
|
|
|
async onload() {
|
|
await this.loadSettings();
|
|
|
|
this.registerView(
|
|
VIEW_TYPE_AI_SIDEBAR,
|
|
(leaf) => new AISidebarView(leaf, this),
|
|
);
|
|
|
|
this.addRibbonIcon("sparkles", "Toggle AI sidebar", () => {
|
|
void this.toggleSidebar();
|
|
});
|
|
|
|
this.addCommand({
|
|
id: "toggle-sidebar",
|
|
name: "Toggle sidebar",
|
|
callback: () => {
|
|
void this.toggleSidebar();
|
|
},
|
|
});
|
|
|
|
this.addSettingTab(new AISidebarSettingTab(this.app, this));
|
|
}
|
|
|
|
async toggleSidebar() {
|
|
const existingLeaf = this.app.workspace.getLeavesOfType(VIEW_TYPE_AI_SIDEBAR).first();
|
|
if (existingLeaf) {
|
|
this.app.workspace.detachLeavesOfType(VIEW_TYPE_AI_SIDEBAR);
|
|
return;
|
|
}
|
|
|
|
const leaf = this.app.workspace.getRightLeaf(false);
|
|
if (!leaf) {
|
|
new Notice("Could not open the AI sidebar.");
|
|
return;
|
|
}
|
|
|
|
await leaf.setViewState({ type: VIEW_TYPE_AI_SIDEBAR, active: true });
|
|
await this.app.workspace.revealLeaf(leaf);
|
|
}
|
|
|
|
async loadSettings() {
|
|
const loaded = await this.loadData() as Partial<AISidebarSettings> | null;
|
|
this.settings = { ...DEFAULT_SETTINGS, ...(loaded ?? {}) };
|
|
this.settings.providers = normalizeProviders(this.settings.providers);
|
|
this.settings.rememberedMessages = Array.isArray(this.settings.rememberedMessages)
|
|
? this.settings.rememberedMessages
|
|
: [];
|
|
}
|
|
|
|
async saveSettings() {
|
|
await this.saveData(this.settings);
|
|
}
|
|
|
|
getProvider(id: string): AgentProvider | undefined {
|
|
return this.settings.providers.find((provider) => provider.id === id);
|
|
}
|
|
|
|
async rememberMessages(messages: ChatMessage[]) {
|
|
if (!this.settings.enableConversationMemory) return;
|
|
this.settings.rememberedMessages = messages.slice(-this.settings.maxMemoryMessages);
|
|
await this.saveSettings();
|
|
}
|
|
|
|
async clearMemory() {
|
|
this.settings.rememberedMessages = [];
|
|
await this.saveSettings();
|
|
}
|
|
|
|
async upsertProviderFromPreset(preset: ProviderPreset) {
|
|
const provider = cloneProvider(preset.provider);
|
|
const existingIndex = this.settings.providers.findIndex((item) => item.id === provider.id);
|
|
if (existingIndex >= 0) {
|
|
this.settings.providers[existingIndex] = {
|
|
...provider,
|
|
apiKey: this.settings.providers[existingIndex].apiKey,
|
|
accessToken: this.settings.providers[existingIndex].accessToken,
|
|
refreshToken: this.settings.providers[existingIndex].refreshToken,
|
|
};
|
|
} else {
|
|
this.settings.providers.push(provider);
|
|
}
|
|
this.settings.defaultProviderId = provider.id;
|
|
await this.saveSettings();
|
|
}
|
|
}
|
|
|
|
class AISidebarView extends ItemView {
|
|
private plugin: AISidebarPlugin;
|
|
private messages: ChatMessage[] = [];
|
|
private providerId: string;
|
|
private accessMode: AccessMode;
|
|
private threadEl: HTMLElement;
|
|
private textareaEl: HTMLTextAreaElement;
|
|
private contextEl: HTMLElement;
|
|
private slashEl: HTMLElement;
|
|
private modelBadgeEl: HTMLElement;
|
|
private activeContextPath = "";
|
|
private refreshTimer: number | undefined;
|
|
private sendButton: ButtonComponent;
|
|
private isRunning = false;
|
|
|
|
constructor(leaf: WorkspaceLeaf, plugin: AISidebarPlugin) {
|
|
super(leaf);
|
|
this.plugin = plugin;
|
|
this.messages = plugin.settings.enableConversationMemory
|
|
? [...plugin.settings.rememberedMessages]
|
|
: [];
|
|
this.providerId = plugin.settings.defaultProviderId;
|
|
this.accessMode = plugin.settings.defaultAccessMode;
|
|
}
|
|
|
|
getViewType(): string {
|
|
return VIEW_TYPE_AI_SIDEBAR;
|
|
}
|
|
|
|
getDisplayText(): string {
|
|
return "AI sidebar";
|
|
}
|
|
|
|
getIcon(): string {
|
|
return "sparkles";
|
|
}
|
|
|
|
async onOpen() {
|
|
this.render();
|
|
this.registerEvent(
|
|
this.app.workspace.on("active-leaf-change", () => {
|
|
this.scheduleContextRefresh();
|
|
}),
|
|
);
|
|
this.registerEvent(
|
|
this.app.workspace.on("file-open", () => {
|
|
this.scheduleContextRefresh();
|
|
}),
|
|
);
|
|
this.registerEvent(
|
|
this.app.vault.on("modify", (file) => {
|
|
if (file instanceof TFile && file.path === this.activeContextPath) {
|
|
this.scheduleContextRefresh();
|
|
}
|
|
}),
|
|
);
|
|
await this.refreshContextPreview();
|
|
}
|
|
|
|
onClose(): Promise<void> {
|
|
this.contentEl.empty();
|
|
return Promise.resolve();
|
|
}
|
|
|
|
private render() {
|
|
this.contentEl.empty();
|
|
this.contentEl.addClass("ai-sidebar");
|
|
|
|
const header = this.contentEl.createDiv("ai-sidebar__header");
|
|
header.createDiv({ cls: "ai-sidebar__title", text: "AI sidebar" });
|
|
header.createDiv({ cls: "ai-sidebar__subtitle", text: "Vault-aware agents" });
|
|
|
|
const controls = this.contentEl.createDiv("ai-sidebar__controls");
|
|
new DropdownComponent(controls)
|
|
.addOptions(this.providerOptions())
|
|
.setValue(this.providerId)
|
|
.onChange((value) => {
|
|
this.providerId = value;
|
|
this.updateModelBadge();
|
|
});
|
|
|
|
new DropdownComponent(controls)
|
|
.addOptions({
|
|
"read-only": "Read only",
|
|
confirm: "Confirm actions",
|
|
"full-access": "Full access",
|
|
})
|
|
.setValue(this.accessMode)
|
|
.onChange((value: AccessMode) => {
|
|
this.accessMode = value;
|
|
void this.refreshContextPreview();
|
|
});
|
|
|
|
this.contextEl = this.contentEl.createDiv("ai-sidebar__context");
|
|
|
|
this.threadEl = this.contentEl.createDiv("ai-sidebar__thread");
|
|
this.renderMessages();
|
|
|
|
const composer = this.contentEl.createDiv("ai-sidebar__composer");
|
|
this.textareaEl = composer.createEl("textarea", {
|
|
cls: "ai-sidebar__input",
|
|
attr: {
|
|
placeholder: "Ask about your vault, draft a note, or request an edit...",
|
|
rows: "4",
|
|
},
|
|
});
|
|
|
|
this.textareaEl.addEventListener("keydown", (event) => {
|
|
if (event.key === "Escape" && !this.slashEl.hasClass("is-hidden")) {
|
|
event.preventDefault();
|
|
this.hideSlashCommands();
|
|
return;
|
|
}
|
|
if (event.key === "Enter" && !event.shiftKey) {
|
|
event.preventDefault();
|
|
void this.sendPrompt();
|
|
}
|
|
});
|
|
this.textareaEl.addEventListener("input", () => {
|
|
void this.updateSlashCommands();
|
|
this.updateModelBadge();
|
|
});
|
|
|
|
this.slashEl = composer.createDiv("ai-sidebar__slash is-hidden");
|
|
|
|
const actions = composer.createDiv("ai-sidebar__composer-actions");
|
|
new ButtonComponent(actions)
|
|
.setButtonText("Refresh context")
|
|
.onClick(() => {
|
|
void this.refreshContextPreview();
|
|
});
|
|
new ButtonComponent(actions)
|
|
.setButtonText("Clear")
|
|
.onClick(() => {
|
|
void this.clearConversation();
|
|
});
|
|
|
|
this.modelBadgeEl = actions.createDiv("ai-sidebar__model-badge");
|
|
this.updateModelBadge();
|
|
|
|
this.sendButton = new ButtonComponent(actions)
|
|
.setCta()
|
|
.setButtonText("Send")
|
|
.onClick(() => {
|
|
void this.sendPrompt();
|
|
});
|
|
}
|
|
|
|
private providerOptions(): Record<string, string> {
|
|
return this.plugin.settings.providers.reduce<Record<string, string>>((options, provider) => {
|
|
options[provider.id] = provider.name || provider.id;
|
|
return options;
|
|
}, {});
|
|
}
|
|
|
|
private renderMessages() {
|
|
this.threadEl.empty();
|
|
|
|
if (this.messages.length === 0) {
|
|
const empty = this.threadEl.createDiv("ai-sidebar__empty");
|
|
empty.createDiv({ text: "Ask a local agent to work with the notes in this vault." });
|
|
empty.createDiv({ text: "Use confirm mode when you want to review file edits first." });
|
|
return;
|
|
}
|
|
|
|
for (const message of this.messages) {
|
|
const messageEl = this.threadEl.createDiv(`ai-sidebar__message ai-sidebar__message--${message.role}`);
|
|
messageEl.createDiv({ cls: "ai-sidebar__message-role", text: message.role });
|
|
messageEl.createEl("pre", { text: message.content });
|
|
}
|
|
|
|
if (this.isRunning) {
|
|
const thinkingEl = this.threadEl.createDiv("ai-sidebar__message ai-sidebar__message--thinking");
|
|
thinkingEl.createDiv({ cls: "ai-sidebar__message-role", text: "assistant" });
|
|
const row = thinkingEl.createDiv("ai-sidebar__typing");
|
|
row.createSpan({ text: "Thinking" });
|
|
const dots = row.createSpan("ai-sidebar__typing-dots");
|
|
dots.createSpan();
|
|
dots.createSpan();
|
|
dots.createSpan();
|
|
}
|
|
|
|
this.threadEl.scrollTo({ top: this.threadEl.scrollHeight });
|
|
}
|
|
|
|
private async refreshContextPreview(prompt = "") {
|
|
const context = await collectVaultContext(
|
|
this.plugin.app,
|
|
this.plugin.settings,
|
|
prompt,
|
|
this.extractSelectedSkillNames(prompt),
|
|
);
|
|
this.activeContextPath = context.activeFile?.path ?? "";
|
|
this.contextEl.empty();
|
|
this.contextEl.createDiv({
|
|
cls: "ai-sidebar__context-title",
|
|
text: `Context preview · ${this.accessModeLabel()}`,
|
|
});
|
|
|
|
const items = [
|
|
context.activeFile ? `Active: ${context.activeFile.path}` : "No active note",
|
|
context.selection ? "Selection included" : "No selection",
|
|
`${context.linkedFiles.length} linked`,
|
|
`${context.backlinkFiles.length} backlinks`,
|
|
`${context.relevantFiles.length} relevant`,
|
|
`${context.baseFiles.length} bases`,
|
|
`${context.selectedSkills.length} skills`,
|
|
];
|
|
|
|
const list = this.contextEl.createEl("ul");
|
|
for (const item of items) {
|
|
list.createEl("li", { text: item });
|
|
}
|
|
}
|
|
|
|
private scheduleContextRefresh() {
|
|
window.clearTimeout(this.refreshTimer);
|
|
this.refreshTimer = window.setTimeout(() => {
|
|
void this.refreshContextPreview(this.textareaEl?.value ?? "");
|
|
}, 150);
|
|
}
|
|
|
|
private accessModeLabel(): string {
|
|
if (this.accessMode === "read-only") return "read only";
|
|
if (this.accessMode === "full-access") return "full access";
|
|
return "confirm actions";
|
|
}
|
|
|
|
private async sendPrompt() {
|
|
const rawPrompt = this.textareaEl.value.trim();
|
|
if (!rawPrompt || this.isRunning) return;
|
|
|
|
const provider = this.plugin.getProvider(this.providerId);
|
|
if (!provider) {
|
|
new Notice("Choose a provider in AI sidebar settings.");
|
|
return;
|
|
}
|
|
|
|
if (!isProviderReady(provider)) {
|
|
new Notice("Connect or configure this provider in AI sidebar settings first.");
|
|
return;
|
|
}
|
|
|
|
const parsed = this.parsePromptControls(rawPrompt, provider);
|
|
if (this.isSlashOnlyPrompt(rawPrompt, parsed)) {
|
|
await this.applySlashControls(provider, parsed);
|
|
this.textareaEl.value = "";
|
|
this.updateModelBadge();
|
|
await this.refreshContextPreview();
|
|
return;
|
|
}
|
|
|
|
this.isRunning = true;
|
|
this.sendButton.setButtonText("Running...");
|
|
this.sendButton.setDisabled(true);
|
|
this.textareaEl.value = "";
|
|
const effectiveAccessMode = parsed.accessMode ?? this.accessMode;
|
|
this.messages.push({ role: "user", content: rawPrompt });
|
|
this.renderMessages();
|
|
|
|
try {
|
|
const context = await collectVaultContext(
|
|
this.plugin.app,
|
|
this.plugin.settings,
|
|
parsed.cleanPrompt,
|
|
parsed.selectedSkillNames,
|
|
);
|
|
await this.refreshContextPreview(rawPrompt);
|
|
const request: AgentRequest = {
|
|
prompt: parsed.cleanPrompt,
|
|
accessMode: effectiveAccessMode,
|
|
context,
|
|
instructions: buildAgentInstructions(effectiveAccessMode),
|
|
conversation: this.plugin.settings.enableConversationMemory ? this.messages.slice(0, -1) : [],
|
|
options: parsed.options,
|
|
};
|
|
|
|
const response = await runProvider(provider, request, this.app);
|
|
const actionResult = await this.handleActions(response);
|
|
const assistantContent = actionResult ? `${response}\n\n${actionResult}` : response;
|
|
this.messages.push({ role: "assistant", content: assistantContent.trim() || "No response." });
|
|
await this.plugin.rememberMessages(this.messages);
|
|
} catch (error) {
|
|
const message = error instanceof Error ? error.message : String(error);
|
|
this.messages.push({ role: "system", content: `Provider failed: ${message}` });
|
|
await this.plugin.rememberMessages(this.messages);
|
|
new Notice("AI provider failed. Check the sidebar for details.");
|
|
} finally {
|
|
this.isRunning = false;
|
|
this.sendButton.setButtonText("Send");
|
|
this.sendButton.setDisabled(false);
|
|
this.updateModelBadge();
|
|
this.renderMessages();
|
|
}
|
|
}
|
|
|
|
private async clearConversation() {
|
|
this.messages = [];
|
|
await this.plugin.clearMemory();
|
|
this.renderMessages();
|
|
new Notice("AI sidebar memory cleared.");
|
|
}
|
|
|
|
private async handleActions(response: string): Promise<string> {
|
|
const actions = extractVaultActions(response);
|
|
if (actions.length === 0) return "";
|
|
|
|
if (this.accessMode === "read-only") {
|
|
return "Vault actions were proposed, but read-only mode blocked all writes.";
|
|
}
|
|
|
|
if (this.accessMode === "confirm") {
|
|
const approved = await confirmVaultActions(this.app, actions);
|
|
if (!approved) return "Vault actions were not applied.";
|
|
}
|
|
|
|
const results: string[] = [];
|
|
for (const action of actions) {
|
|
try {
|
|
await applyVaultAction(this.app, action);
|
|
results.push(`Applied ${action.type}: ${action.path}`);
|
|
} catch (error) {
|
|
const message = error instanceof Error ? error.message : String(error);
|
|
results.push(`Failed ${action.type}: ${action.path} · ${message}`);
|
|
}
|
|
}
|
|
return results.join("\n");
|
|
}
|
|
|
|
private async updateSlashCommands() {
|
|
const query = this.currentSlashQuery();
|
|
if (query === null) {
|
|
this.hideSlashCommands();
|
|
return;
|
|
}
|
|
|
|
const provider = this.plugin.getProvider(this.providerId);
|
|
const commands = provider ? nativeSlashCommands(provider, query, this.accessMode) : [];
|
|
const skills = await listAgentSkills(this.plugin.app, query);
|
|
this.slashEl.empty();
|
|
|
|
if (commands.length === 0 && skills.length === 0) {
|
|
this.hideSlashCommands();
|
|
return;
|
|
}
|
|
|
|
this.slashEl.removeClass("is-hidden");
|
|
if (skills.length > 0) {
|
|
this.slashEl.createDiv({ cls: "ai-sidebar__slash-section", text: "Skills" });
|
|
}
|
|
for (const skill of skills.slice(0, 12)) {
|
|
const item = this.slashEl.createDiv("ai-sidebar__slash-item");
|
|
item.createDiv({ cls: "ai-sidebar__slash-name", text: `/${skill.name}` });
|
|
item.createDiv({ cls: "ai-sidebar__slash-path", text: skill.path });
|
|
item.addEventListener("mousedown", (event) => {
|
|
event.preventDefault();
|
|
this.insertSlashToken(`/${skill.name}`);
|
|
});
|
|
}
|
|
if (commands.length > 0) {
|
|
this.slashEl.createDiv({ cls: "ai-sidebar__slash-section", text: "Controls" });
|
|
}
|
|
for (const command of commands.slice(0, 8)) {
|
|
const item = this.slashEl.createDiv("ai-sidebar__slash-item");
|
|
item.createDiv({ cls: "ai-sidebar__slash-name", text: command.label });
|
|
item.createDiv({ cls: "ai-sidebar__slash-path", text: command.description });
|
|
item.addEventListener("mousedown", (event) => {
|
|
event.preventDefault();
|
|
this.insertSlashToken(command.insert);
|
|
});
|
|
}
|
|
}
|
|
|
|
private hideSlashCommands() {
|
|
this.slashEl.empty();
|
|
this.slashEl.addClass("is-hidden");
|
|
}
|
|
|
|
private currentSlashQuery(): string | null {
|
|
const cursor = this.textareaEl.selectionStart;
|
|
const beforeCursor = this.textareaEl.value.slice(0, cursor);
|
|
const match = beforeCursor.match(/(?:^|\s)\/([A-Za-z0-9_.:-]*)$/);
|
|
return match ? match[1].toLowerCase() : null;
|
|
}
|
|
|
|
private insertSlashToken(token: string) {
|
|
const cursor = this.textareaEl.selectionStart;
|
|
const value = this.textareaEl.value;
|
|
const beforeCursor = value.slice(0, cursor);
|
|
const afterCursor = value.slice(cursor);
|
|
const replaced = beforeCursor.replace(/(?:^|\s)\/([A-Za-z0-9_.:-]*)$/, (match) => {
|
|
const prefix = match.startsWith(" ") ? " " : "";
|
|
return `${prefix}${token} `;
|
|
});
|
|
this.textareaEl.value = `${replaced}${afterCursor}`;
|
|
this.textareaEl.focus();
|
|
this.textareaEl.selectionStart = replaced.length;
|
|
this.textareaEl.selectionEnd = replaced.length;
|
|
this.hideSlashCommands();
|
|
this.scheduleContextRefresh();
|
|
}
|
|
|
|
private extractSelectedSkillNames(prompt: string): string[] {
|
|
const native = new Set(["model", "reasoning", "access", "memory"]);
|
|
return Array.from(prompt.matchAll(/(?:^|\s)\/([A-Za-z0-9_.-]+)/g), (match) => match[1])
|
|
.filter((name) => !native.has(name.split(":")[0].toLowerCase()));
|
|
}
|
|
|
|
private parsePromptControls(prompt: string, provider: AgentProvider): ParsedPrompt {
|
|
const options: AgentRequestOptions = {
|
|
model: provider.model,
|
|
reasoningEffort: provider.reasoningEffort,
|
|
memoryEnabled: this.plugin.settings.enableConversationMemory,
|
|
};
|
|
let accessMode: AccessMode | undefined;
|
|
|
|
const cleanPrompt = prompt.replace(/(?:^|\s)\/(model|reasoning|access|memory):([A-Za-z0-9_.-]+)/gi, (match: string, key: string, value: string) => {
|
|
const normalizedKey = String(key).toLowerCase();
|
|
const normalizedValue = String(value).toLowerCase();
|
|
if (normalizedKey === "model") {
|
|
options.model = value;
|
|
} else if (normalizedKey === "reasoning" && isReasoningEffort(normalizedValue)) {
|
|
options.reasoningEffort = normalizedValue;
|
|
} else if (normalizedKey === "access" && isAccessMode(normalizedValue)) {
|
|
accessMode = normalizedValue;
|
|
} else if (normalizedKey === "memory") {
|
|
options.memoryEnabled = normalizedValue === "on";
|
|
}
|
|
return match.startsWith(" ") ? " " : "";
|
|
}).trim();
|
|
|
|
return {
|
|
cleanPrompt,
|
|
selectedSkillNames: this.extractSelectedSkillNames(prompt),
|
|
options,
|
|
accessMode,
|
|
};
|
|
}
|
|
|
|
private isSlashOnlyPrompt(prompt: string, parsed: ParsedPrompt): boolean {
|
|
return parsed.cleanPrompt.length === 0 && this.extractSelectedSkillNames(prompt).length === 0;
|
|
}
|
|
|
|
private async applySlashControls(provider: AgentProvider, parsed: ParsedPrompt) {
|
|
const changes: string[] = [];
|
|
if (parsed.options.model && parsed.options.model !== provider.model) {
|
|
provider.model = parsed.options.model;
|
|
changes.push(`model ${parsed.options.model}`);
|
|
}
|
|
if (parsed.options.reasoningEffort && parsed.options.reasoningEffort !== provider.reasoningEffort) {
|
|
provider.reasoningEffort = parsed.options.reasoningEffort;
|
|
changes.push(`reasoning ${parsed.options.reasoningEffort}`);
|
|
}
|
|
if (parsed.accessMode && parsed.accessMode !== this.accessMode) {
|
|
this.accessMode = parsed.accessMode;
|
|
this.plugin.settings.defaultAccessMode = parsed.accessMode;
|
|
changes.push(`access ${this.accessModeLabel()}`);
|
|
}
|
|
if (parsed.options.memoryEnabled !== this.plugin.settings.enableConversationMemory) {
|
|
this.plugin.settings.enableConversationMemory = parsed.options.memoryEnabled;
|
|
changes.push(`memory ${parsed.options.memoryEnabled ? "on" : "off"}`);
|
|
}
|
|
await this.plugin.saveSettings();
|
|
new Notice(changes.length > 0 ? `Updated ${changes.join(", ")}.` : "Slash command applied.");
|
|
}
|
|
|
|
private updateModelBadge() {
|
|
if (!this.modelBadgeEl) return;
|
|
const provider = this.plugin.getProvider(this.providerId);
|
|
const override = this.textareaEl?.value.match(/(?:^|\s)\/model:([A-Za-z0-9_.:/-]+)/i)?.[1];
|
|
const model = override || provider?.model || parseProviderModels(provider ?? DEFAULT_SETTINGS.providers[0]).first() || "default";
|
|
this.modelBadgeEl.setText(model);
|
|
this.modelBadgeEl.toggleClass("is-override", Boolean(override));
|
|
this.modelBadgeEl.setAttr("aria-label", override ? `Model override: ${model}` : `Model: ${model}`);
|
|
}
|
|
}
|
|
|
|
class AISidebarSettingTab extends PluginSettingTab {
|
|
plugin: AISidebarPlugin;
|
|
|
|
constructor(app: App, plugin: AISidebarPlugin) {
|
|
super(app, plugin);
|
|
this.plugin = plugin;
|
|
}
|
|
|
|
display(): void {
|
|
const { containerEl } = this;
|
|
containerEl.empty();
|
|
|
|
new Setting(containerEl)
|
|
.setName("Default provider")
|
|
.setDesc("The AI provider used when the sidebar opens.")
|
|
.addDropdown((dropdown) => {
|
|
dropdown.addOptions(this.providerOptions());
|
|
dropdown.setValue(this.plugin.settings.defaultProviderId);
|
|
dropdown.onChange(async (value) => {
|
|
this.plugin.settings.defaultProviderId = value;
|
|
await this.plugin.saveSettings();
|
|
});
|
|
});
|
|
|
|
new Setting(containerEl)
|
|
.setName("Default vault access")
|
|
.setDesc("How much permission the agent has when it proposes changes.")
|
|
.addDropdown((dropdown) => {
|
|
dropdown
|
|
.addOption("read-only", "Read only")
|
|
.addOption("confirm", "Confirm actions")
|
|
.addOption("full-access", "Full access")
|
|
.setValue(this.plugin.settings.defaultAccessMode)
|
|
.onChange(async (value: AccessMode) => {
|
|
this.plugin.settings.defaultAccessMode = value;
|
|
await this.plugin.saveSettings();
|
|
});
|
|
});
|
|
|
|
new Setting(containerEl)
|
|
.setName("Sidebar shortcut")
|
|
.setDesc("Set a shortcut from Obsidian's hotkeys settings by searching for toggle sidebar.");
|
|
|
|
new Setting(containerEl)
|
|
.setName("Include folders")
|
|
.setDesc("Comma-separated folder prefixes to include. Leave blank for the whole vault.")
|
|
.addText((text) => {
|
|
text
|
|
.setPlaceholder("Projects, daily notes")
|
|
.setValue(this.plugin.settings.includeFolders)
|
|
.onChange(async (value) => {
|
|
this.plugin.settings.includeFolders = value;
|
|
await this.plugin.saveSettings();
|
|
});
|
|
});
|
|
|
|
new Setting(containerEl)
|
|
.setName("Exclude folders")
|
|
.setDesc("Comma-separated folder prefixes that should never be sent to an agent.")
|
|
.addText((text) => {
|
|
text
|
|
.setValue(this.plugin.settings.excludeFolders)
|
|
.onChange(async (value) => {
|
|
this.plugin.settings.excludeFolders = value;
|
|
await this.plugin.saveSettings();
|
|
});
|
|
});
|
|
|
|
new Setting(containerEl)
|
|
.setName("Max context characters")
|
|
.setDesc("Upper bound for note text sent to the agent.")
|
|
.addText((text) => {
|
|
text
|
|
.setValue(String(this.plugin.settings.maxContextChars))
|
|
.onChange(async (value) => {
|
|
const parsed = Number(value);
|
|
if (Number.isFinite(parsed) && parsed > 1000) {
|
|
this.plugin.settings.maxContextChars = parsed;
|
|
await this.plugin.saveSettings();
|
|
}
|
|
});
|
|
});
|
|
|
|
new Setting(containerEl)
|
|
.setName("Conversation memory")
|
|
.setDesc("Remember previous sidebar messages after closing and reopening Obsidian.")
|
|
.addToggle((toggle) => {
|
|
toggle
|
|
.setValue(this.plugin.settings.enableConversationMemory)
|
|
.onChange(async (value) => {
|
|
this.plugin.settings.enableConversationMemory = value;
|
|
await this.plugin.saveSettings();
|
|
});
|
|
});
|
|
|
|
new Setting(containerEl)
|
|
.setName("Memory length")
|
|
.setDesc("Maximum number of recent sidebar messages to remember.")
|
|
.addText((text) => {
|
|
text
|
|
.setValue(String(this.plugin.settings.maxMemoryMessages))
|
|
.onChange(async (value) => {
|
|
const parsed = Number(value);
|
|
if (Number.isFinite(parsed) && parsed >= 2) {
|
|
this.plugin.settings.maxMemoryMessages = parsed;
|
|
await this.plugin.saveSettings();
|
|
}
|
|
});
|
|
})
|
|
.addButton((button) => {
|
|
button.setButtonText("Clear memory").onClick(async () => {
|
|
await this.plugin.clearMemory();
|
|
new Notice("AI sidebar memory cleared.");
|
|
});
|
|
});
|
|
|
|
new Setting(containerEl)
|
|
.setName("Connect a provider")
|
|
.setHeading();
|
|
this.renderProviderPresets(containerEl);
|
|
|
|
new Setting(containerEl)
|
|
.setName("Connected providers")
|
|
.setHeading();
|
|
for (const provider of this.plugin.settings.providers) {
|
|
this.renderProviderSetting(containerEl, provider);
|
|
}
|
|
|
|
new Setting(containerEl)
|
|
.setName("Advanced provider")
|
|
.setDesc("Create a custom API, OAUTH, or local CLI provider.")
|
|
.addButton((button) => {
|
|
button.setButtonText("Add custom").onClick(async () => {
|
|
const id = `provider-${Date.now()}`;
|
|
this.plugin.settings.providers.push({ id, name: "New provider", authType: "oauth", command: "" });
|
|
await this.plugin.saveSettings();
|
|
this.display();
|
|
});
|
|
});
|
|
}
|
|
|
|
private renderProviderPresets(containerEl: HTMLElement) {
|
|
const grid = containerEl.createDiv("ai-sidebar-provider-grid");
|
|
for (const preset of PROVIDER_PRESETS) {
|
|
const provider = this.plugin.getProvider(preset.provider.id);
|
|
const card = grid.createDiv("ai-sidebar-provider-card");
|
|
card.createDiv({ cls: "ai-sidebar-provider-card__name", text: preset.name });
|
|
card.createDiv({ cls: "ai-sidebar-provider-card__desc", text: preset.description });
|
|
const status = provider ? providerConnectionLabel(provider) : "Not added";
|
|
card.createDiv({ cls: "ai-sidebar-provider-card__status", text: status });
|
|
|
|
const actions = card.createDiv("ai-sidebar-provider-card__actions");
|
|
new ButtonComponent(actions)
|
|
.setButtonText(provider ? "Use" : "Add")
|
|
.onClick(async () => {
|
|
await this.plugin.upsertProviderFromPreset(preset);
|
|
this.display();
|
|
});
|
|
|
|
new ButtonComponent(actions)
|
|
.setCta()
|
|
.setButtonText(providerConnectionActionText(provider ?? preset.provider))
|
|
.onClick(async () => {
|
|
await this.plugin.upsertProviderFromPreset(preset);
|
|
const connectedProvider = this.plugin.getProvider(preset.provider.id) ?? preset.provider;
|
|
if (await startProviderSignIn(connectedProvider)) {
|
|
connectedProvider.connectedAt = Date.now();
|
|
await this.plugin.saveSettings();
|
|
}
|
|
this.display();
|
|
});
|
|
}
|
|
}
|
|
|
|
private providerOptions(): Record<string, string> {
|
|
return this.plugin.settings.providers.reduce<Record<string, string>>((options, provider) => {
|
|
options[provider.id] = provider.name || provider.id;
|
|
return options;
|
|
}, {});
|
|
}
|
|
|
|
private renderProviderSetting(containerEl: HTMLElement, provider: AgentProvider) {
|
|
const wrapper = containerEl.createDiv("ai-sidebar-settings-provider");
|
|
const header = wrapper.createDiv("ai-sidebar-settings-provider__header");
|
|
const title = header.createDiv("ai-sidebar-settings-provider__title");
|
|
title.createDiv({ cls: "ai-sidebar-settings-provider__name", text: provider.name || provider.id });
|
|
title.createDiv({ cls: "ai-sidebar-settings-provider__desc", text: this.providerDescription(provider) });
|
|
header.createSpan({
|
|
cls: `ai-sidebar-settings-provider__badge ${isProviderConnected(provider) ? "is-connected" : ""}`,
|
|
text: providerConnectionLabel(provider),
|
|
});
|
|
|
|
const actions = wrapper.createDiv("ai-sidebar-settings-provider__actions");
|
|
new ButtonComponent(actions)
|
|
.setButtonText(this.plugin.settings.defaultProviderId === provider.id ? "Default" : "Use")
|
|
.setDisabled(this.plugin.settings.defaultProviderId === provider.id)
|
|
.onClick(async () => {
|
|
this.plugin.settings.defaultProviderId = provider.id;
|
|
await this.plugin.saveSettings();
|
|
this.display();
|
|
});
|
|
this.configureConnectButton(new ButtonComponent(actions), provider);
|
|
new ButtonComponent(actions)
|
|
.setIcon("trash")
|
|
.setTooltip("Remove provider")
|
|
.onClick(async () => {
|
|
this.plugin.settings.providers = this.plugin.settings.providers.filter((item) => item !== provider);
|
|
if (this.plugin.settings.defaultProviderId === provider.id) {
|
|
this.plugin.settings.defaultProviderId = this.plugin.settings.providers.first()?.id ?? "";
|
|
}
|
|
await this.plugin.saveSettings();
|
|
this.display();
|
|
});
|
|
|
|
const fields = wrapper.createDiv("ai-sidebar-settings-provider__fields");
|
|
this.renderTextField(fields, "Name", provider.name, async (value) => {
|
|
provider.name = value;
|
|
await this.plugin.saveSettings();
|
|
this.display();
|
|
});
|
|
|
|
if (provider.authType === "cli") {
|
|
this.renderTextField(fields, "Command", provider.command, async (value) => {
|
|
provider.command = value;
|
|
await this.plugin.saveSettings();
|
|
});
|
|
if (provider.signInCommand) {
|
|
this.renderTextField(fields, "Sign-in command", provider.signInCommand, async (value) => {
|
|
provider.signInCommand = value;
|
|
provider.connectedAt = undefined;
|
|
await this.plugin.saveSettings();
|
|
});
|
|
}
|
|
}
|
|
|
|
if (provider.authType === "api-key") {
|
|
this.renderTextField(fields, "API key", provider.apiKey ?? "", async (value) => {
|
|
provider.apiKey = value;
|
|
provider.connectedAt = value ? Date.now() : undefined;
|
|
await this.plugin.saveSettings();
|
|
this.display();
|
|
}, true);
|
|
this.renderTextField(fields, "Endpoint", provider.apiBaseUrl ?? "", async (value) => {
|
|
provider.apiBaseUrl = value;
|
|
await this.plugin.saveSettings();
|
|
});
|
|
this.renderTextField(fields, "Default model", provider.model ?? "", async (value) => {
|
|
provider.model = value;
|
|
await this.plugin.saveSettings();
|
|
});
|
|
this.renderTextField(fields, "Slash models", provider.models ?? "", async (value) => {
|
|
provider.models = value;
|
|
await this.plugin.saveSettings();
|
|
});
|
|
}
|
|
|
|
if (provider.authType === "oauth") {
|
|
this.renderTextField(fields, "Authorization URL", provider.authorizationUrl ?? "", async (value) => {
|
|
provider.authorizationUrl = value;
|
|
await this.plugin.saveSettings();
|
|
});
|
|
this.renderTextField(fields, "Client ID", provider.clientId ?? "", async (value) => {
|
|
provider.clientId = value;
|
|
await this.plugin.saveSettings();
|
|
});
|
|
this.renderTextField(fields, "Access token", provider.accessToken ?? "", async (value) => {
|
|
provider.accessToken = value;
|
|
provider.connectedAt = value ? Date.now() : undefined;
|
|
await this.plugin.saveSettings();
|
|
this.display();
|
|
}, true);
|
|
}
|
|
}
|
|
|
|
private renderTextField(
|
|
containerEl: HTMLElement,
|
|
label: string,
|
|
value: string,
|
|
onChange: (value: string) => Promise<void>,
|
|
secret = false,
|
|
) {
|
|
const field = containerEl.createDiv("ai-sidebar-settings-field");
|
|
field.createDiv({ cls: "ai-sidebar-settings-field__label", text: label });
|
|
const input = field.createEl("input", {
|
|
cls: "ai-sidebar-settings-field__input",
|
|
attr: { type: secret ? "password" : "text" },
|
|
});
|
|
input.value = value;
|
|
input.addEventListener("change", () => {
|
|
void onChange(input.value);
|
|
});
|
|
}
|
|
|
|
private providerDescription(provider: AgentProvider): string {
|
|
if (provider.authType === "api-key") {
|
|
return provider.apiKey ? "Connected with API key." : "Add an API key to connect.";
|
|
}
|
|
if (provider.authType === "oauth") {
|
|
return provider.accessToken ? "Connected with OAuth." : "Connect with OAuth when the provider exposes a desktop OAuth app.";
|
|
}
|
|
return provider.command ? `Runs local command: ${provider.command}` : "Add the local CLI command.";
|
|
}
|
|
|
|
private configureConnectButton(button: ButtonComponent, provider: AgentProvider) {
|
|
button
|
|
.setButtonText(providerConnectionActionText(provider))
|
|
.onClick(async () => {
|
|
if (await startProviderSignIn(provider)) {
|
|
provider.connectedAt = Date.now();
|
|
await this.plugin.saveSettings();
|
|
this.display();
|
|
}
|
|
});
|
|
}
|
|
}
|
|
|
|
class ConfirmActionsModal extends Modal {
|
|
private actions: VaultAction[];
|
|
private resolve: (approved: boolean) => void;
|
|
|
|
constructor(app: App, actions: VaultAction[], resolve: (approved: boolean) => void) {
|
|
super(app);
|
|
this.actions = actions;
|
|
this.resolve = resolve;
|
|
}
|
|
|
|
onOpen() {
|
|
const { contentEl } = this;
|
|
contentEl.empty();
|
|
new Setting(contentEl)
|
|
.setName("Apply AI vault actions?")
|
|
.setHeading();
|
|
contentEl.createEl("p", { text: "Review these proposed file changes before they are applied." });
|
|
|
|
for (const action of this.actions) {
|
|
const actionEl = contentEl.createDiv("ai-sidebar-action-preview");
|
|
actionEl.createEl("strong", { text: `${action.type}: ${action.path}` });
|
|
if (action.type === "rename") {
|
|
actionEl.createDiv({ text: `New path: ${action.newPath}` });
|
|
}
|
|
if ("content" in action) {
|
|
actionEl.createEl("pre", { text: action.content.slice(0, 1200) });
|
|
}
|
|
}
|
|
|
|
new Setting(contentEl)
|
|
.addButton((button) => {
|
|
button.setButtonText("Cancel").onClick(() => {
|
|
this.resolve(false);
|
|
this.close();
|
|
});
|
|
})
|
|
.addButton((button) => {
|
|
button.setCta().setButtonText("Apply").onClick(() => {
|
|
this.resolve(true);
|
|
this.close();
|
|
});
|
|
});
|
|
}
|
|
|
|
onClose() {
|
|
this.contentEl.empty();
|
|
}
|
|
}
|
|
|
|
async function collectVaultContext(
|
|
app: App,
|
|
settings: AISidebarSettings,
|
|
prompt: string,
|
|
selectedSkillNames: string[] = [],
|
|
): Promise<VaultContext> {
|
|
const activeView = app.workspace.getActiveViewOfType(MarkdownView);
|
|
const activeFile = activeView?.file ?? app.workspace.getActiveFile();
|
|
const selection = activeView?.editor.getSelection() || undefined;
|
|
const budget = new ContextBudget(settings.maxContextChars);
|
|
|
|
const context: VaultContext = {
|
|
selection,
|
|
linkedFiles: [],
|
|
backlinkFiles: [],
|
|
relevantFiles: [],
|
|
baseFiles: [],
|
|
selectedSkills: [],
|
|
};
|
|
|
|
const activeContext = activeFile ? await readContextFile(app, activeFile, "active note", budget) : undefined;
|
|
if (activeContext) context.activeFile = activeContext;
|
|
|
|
const linked = activeFile ? getLinkedFiles(app, activeFile) : [];
|
|
for (const file of linked) {
|
|
const item = await readContextFile(app, file, "linked note", budget);
|
|
if (item) context.linkedFiles.push(item);
|
|
}
|
|
|
|
const backlinks = activeFile ? getBacklinkFiles(app, activeFile) : [];
|
|
for (const file of backlinks) {
|
|
const item = await readContextFile(app, file, "backlink", budget);
|
|
if (item) context.backlinkFiles.push(item);
|
|
}
|
|
|
|
const baseFiles = app.vault
|
|
.getFiles()
|
|
.filter((file) => file.extension === "base" && shouldIncludeFile(app, file, settings))
|
|
.slice(0, 5);
|
|
for (const file of baseFiles) {
|
|
const item = await readContextFile(app, file, "base file", budget);
|
|
if (item) context.baseFiles.push(item);
|
|
}
|
|
|
|
const relatedFiles = await findRelevantFiles(app, settings, prompt, activeFile, budget.remaining());
|
|
for (const file of relatedFiles) {
|
|
const item = await readContextFile(app, file, "relevant match", budget);
|
|
if (item) context.relevantFiles.push(item);
|
|
}
|
|
|
|
context.selectedSkills = await readSelectedSkills(app, selectedSkillNames, budget);
|
|
|
|
return context;
|
|
}
|
|
|
|
async function readContextFile(
|
|
app: App,
|
|
file: TFile,
|
|
reason: string,
|
|
budget: ContextBudget,
|
|
): Promise<VaultContextFile | undefined> {
|
|
if (!budget.hasRoom()) return undefined;
|
|
const content = await app.vault.cachedRead(file);
|
|
const clipped = budget.take(content);
|
|
return { path: file.path, content: clipped, reason };
|
|
}
|
|
|
|
function getLinkedFiles(app: App, activeFile: TFile): TFile[] {
|
|
const cache = app.metadataCache.getFileCache(activeFile);
|
|
const links = cache?.links ?? [];
|
|
const files: TFile[] = [];
|
|
|
|
for (const link of links) {
|
|
const linkedFile = app.metadataCache.getFirstLinkpathDest(link.link, activeFile.path);
|
|
if (linkedFile) files.push(linkedFile);
|
|
}
|
|
|
|
return uniqueFiles(files).slice(0, 8);
|
|
}
|
|
|
|
function getBacklinkFiles(app: App, activeFile: TFile): TFile[] {
|
|
const resolvedLinks = app.metadataCache.resolvedLinks;
|
|
const files: TFile[] = [];
|
|
|
|
for (const [sourcePath, targets] of Object.entries(resolvedLinks)) {
|
|
if (targets[activeFile.path]) {
|
|
const file = app.vault.getAbstractFileByPath(sourcePath);
|
|
if (file instanceof TFile) files.push(file);
|
|
}
|
|
}
|
|
|
|
return uniqueFiles(files).slice(0, 8);
|
|
}
|
|
|
|
async function findRelevantFiles(
|
|
app: App,
|
|
settings: AISidebarSettings,
|
|
prompt: string,
|
|
activeFile: TFile | null,
|
|
maxChars: number,
|
|
): Promise<TFile[]> {
|
|
if (!prompt.trim() || maxChars <= 0) return [];
|
|
const terms = prompt
|
|
.toLowerCase()
|
|
.split(/[^a-z0-9/_-]+/i)
|
|
.filter((term) => term.length > 2)
|
|
.slice(0, 16);
|
|
if (terms.length === 0) return [];
|
|
|
|
const scored: Array<{ file: TFile; score: number }> = [];
|
|
const files = app.vault
|
|
.getFiles()
|
|
.filter((file) => file !== activeFile && shouldIncludeFile(app, file, settings) && isReadableContextFile(file));
|
|
|
|
for (const file of files) {
|
|
const content = (await app.vault.cachedRead(file)).toLowerCase();
|
|
const path = file.path.toLowerCase();
|
|
let score = 0;
|
|
for (const term of terms) {
|
|
if (path.includes(term)) score += 4;
|
|
const matches = content.match(new RegExp(escapeRegExp(term), "g"));
|
|
score += matches ? Math.min(matches.length, 8) : 0;
|
|
}
|
|
if (score > 0) scored.push({ file, score });
|
|
}
|
|
|
|
return scored
|
|
.sort((a, b) => b.score - a.score)
|
|
.slice(0, 10)
|
|
.map((item) => item.file);
|
|
}
|
|
|
|
function shouldIncludeFile(app: App, file: TFile, settings: AISidebarSettings): boolean {
|
|
const includes = parseFolderList(settings.includeFolders);
|
|
const excludes = [app.vault.configDir, ...parseFolderList(settings.excludeFolders)];
|
|
if (includes.length > 0 && !includes.some((folder) => file.path.startsWith(folder))) return false;
|
|
if (excludes.some((folder) => file.path.startsWith(folder))) return false;
|
|
return isReadableContextFile(file);
|
|
}
|
|
|
|
function isReadableContextFile(file: TFile): boolean {
|
|
return ["md", "canvas", "base", "json", "txt"].includes(file.extension);
|
|
}
|
|
|
|
function nativeSlashCommands(
|
|
provider: AgentProvider,
|
|
query: string,
|
|
currentAccessMode: AccessMode,
|
|
): Array<{ label: string; description: string; insert: string }> {
|
|
const commands: Array<{ label: string; description: string; insert: string }> = [];
|
|
const modelChoices = parseProviderModels(provider);
|
|
|
|
for (const model of modelChoices) {
|
|
commands.push({
|
|
label: `/model:${model}`,
|
|
description: `Use ${model} for this request`,
|
|
insert: `/model:${model}`,
|
|
});
|
|
}
|
|
|
|
if (provider.authType === "api-key" || provider.id.includes("codex") || provider.id.includes("openai")) {
|
|
for (const effort of ["low", "medium", "high"] as ReasoningEffort[]) {
|
|
commands.push({
|
|
label: `/reasoning:${effort}`,
|
|
description: `Set reasoning effort to ${effort}`,
|
|
insert: `/reasoning:${effort}`,
|
|
});
|
|
}
|
|
}
|
|
|
|
for (const mode of ["read-only", "confirm", "full-access"] as AccessMode[]) {
|
|
commands.push({
|
|
label: `/access:${mode}`,
|
|
description: mode === currentAccessMode ? "Current vault access mode" : `Use ${mode} for this request`,
|
|
insert: `/access:${mode}`,
|
|
});
|
|
}
|
|
|
|
commands.push(
|
|
{ label: "/memory:on", description: "Include remembered chat history for this request", insert: "/memory:on" },
|
|
{ label: "/memory:off", description: "Do not include remembered chat history for this request", insert: "/memory:off" },
|
|
);
|
|
|
|
const normalizedQuery = query.toLowerCase();
|
|
return commands.filter((command) => command.label.slice(1).toLowerCase().includes(normalizedQuery));
|
|
}
|
|
|
|
function parseProviderModels(provider: AgentProvider): string[] {
|
|
const configured = provider.models
|
|
?.split(",")
|
|
.map((model) => model.trim())
|
|
.filter(Boolean) ?? [];
|
|
const models = configured.length > 0 ? configured : [provider.model].filter((model): model is string => Boolean(model));
|
|
return Array.from(new Set(models)).slice(0, 12);
|
|
}
|
|
|
|
async function listAgentSkills(app: App, query = ""): Promise<SkillReference[]> {
|
|
const normalizedQuery = query.toLowerCase();
|
|
const vaultSkills = app.vault
|
|
.getFiles()
|
|
.filter((file) => isSkillFile(file))
|
|
.map((file) => ({
|
|
name: skillNameFromPath(file.path),
|
|
path: file.path,
|
|
source: "vault" as const,
|
|
}));
|
|
const adapterSkills = await listAgentSkillsFromAdapter(app);
|
|
const globalSkills = await listGlobalAgentSkills();
|
|
const skills = [...vaultSkills, ...adapterSkills, ...globalSkills]
|
|
.filter((skill) => !normalizedQuery || skill.name.toLowerCase().includes(normalizedQuery))
|
|
.sort((a, b) => a.name.localeCompare(b.name));
|
|
|
|
const seen = new Set<string>();
|
|
return skills.filter((skill) => {
|
|
const key = `${skill.source}:${skill.name.toLowerCase()}`;
|
|
if (seen.has(key)) return false;
|
|
seen.add(key);
|
|
return true;
|
|
});
|
|
}
|
|
|
|
async function listAgentSkillsFromAdapter(app: App): Promise<SkillReference[]> {
|
|
const roots = [".agent/skills", ".agents/skills", "agent/skills", "agents/skills"];
|
|
const files: string[] = [];
|
|
for (const root of roots) {
|
|
files.push(...await listAdapterFiles(app, root));
|
|
}
|
|
return files
|
|
.filter((path) => isSkillPath(path))
|
|
.map((path) => ({
|
|
name: skillNameFromPath(path),
|
|
path,
|
|
source: "vault" as const,
|
|
}));
|
|
}
|
|
|
|
async function listGlobalAgentSkills(): Promise<SkillReference[]> {
|
|
const roots = [
|
|
path.join(homedir(), ".agent", "skills", "skills"),
|
|
path.join(homedir(), ".agents", "skills", "skills"),
|
|
];
|
|
const files: string[] = [];
|
|
for (const root of roots) {
|
|
files.push(...await listFilesystemFiles(root));
|
|
}
|
|
return files
|
|
.filter((filePath) => isGlobalSkillPath(filePath))
|
|
.map((filePath) => ({
|
|
name: skillNameFromPath(filePath),
|
|
path: filePath,
|
|
source: "global" as const,
|
|
}));
|
|
}
|
|
|
|
async function listFilesystemFiles(folder: string): Promise<string[]> {
|
|
try {
|
|
const entries = await fs.readdir(folder, { withFileTypes: true });
|
|
const results = await Promise.all(entries.map(async (entry) => {
|
|
const childPath = path.join(folder, entry.name);
|
|
if (entry.isDirectory()) return listFilesystemFiles(childPath);
|
|
if (entry.isFile()) return [childPath];
|
|
return [];
|
|
}));
|
|
return results.flat();
|
|
} catch {
|
|
return [];
|
|
}
|
|
}
|
|
|
|
async function listAdapterFiles(app: App, folder: string): Promise<string[]> {
|
|
try {
|
|
const listed = await app.vault.adapter.list(folder);
|
|
const childFiles = listed.files;
|
|
const nested = await Promise.all(listed.folders.map((child) => listAdapterFiles(app, child)));
|
|
return [...childFiles, ...nested.flat()];
|
|
} catch {
|
|
return [];
|
|
}
|
|
}
|
|
|
|
async function readSelectedSkills(
|
|
app: App,
|
|
selectedSkillNames: string[],
|
|
budget: ContextBudget,
|
|
): Promise<AgentSkill[]> {
|
|
const names = new Set(selectedSkillNames.map((name) => name.toLowerCase()));
|
|
if (names.size === 0) return [];
|
|
|
|
const skills: AgentSkill[] = [];
|
|
const skillFiles = [...await listAgentSkillsFromAdapter(app), ...await listGlobalAgentSkills()];
|
|
const vaultFiles = app.vault
|
|
.getFiles()
|
|
.filter((candidate) => isSkillFile(candidate))
|
|
.map((file) => ({ name: skillNameFromPath(file.path), path: file.path, source: "vault" as const }));
|
|
for (const skillFile of [...vaultFiles, ...skillFiles]) {
|
|
const name = skillFile.name;
|
|
if (!names.has(name.toLowerCase()) || !budget.hasRoom()) continue;
|
|
const content = await readSkillContent(app, skillFile);
|
|
skills.push({
|
|
name,
|
|
path: skillFile.path,
|
|
content: budget.take(content),
|
|
});
|
|
}
|
|
return skills;
|
|
}
|
|
|
|
async function readSkillContent(app: App, skill: SkillReference): Promise<string> {
|
|
if (skill.source === "global") return fs.readFile(skill.path, "utf8");
|
|
const file = app.vault.getAbstractFileByPath(skill.path);
|
|
if (file instanceof TFile) return app.vault.cachedRead(file);
|
|
return app.vault.adapter.read(skill.path);
|
|
}
|
|
|
|
function isSkillFile(file: TFile): boolean {
|
|
return isSkillPath(file.path);
|
|
}
|
|
|
|
function isSkillPath(path: string): boolean {
|
|
if (!hasSupportedSkillExtension(path)) return false;
|
|
const normalized = path.replace(/^\/+/, "");
|
|
return normalized.startsWith(".agent/skills/")
|
|
|| normalized.startsWith(".agents/skills/")
|
|
|| normalized.startsWith("agent/skills/")
|
|
|| normalized.startsWith("agents/skills/");
|
|
}
|
|
|
|
function hasSupportedSkillExtension(path: string): boolean {
|
|
const extension = path.split(".").last()?.toLowerCase() ?? "";
|
|
return ["md", "txt", "json", "yaml", "yml", "prompt"].includes(extension);
|
|
}
|
|
|
|
function isGlobalSkillPath(filePath: string): boolean {
|
|
return path.basename(filePath).toLowerCase() === "skill.md";
|
|
}
|
|
|
|
function skillNameFromPath(path: string): string {
|
|
const parts = path.split("/");
|
|
const fileName = parts.last() ?? path;
|
|
if (fileName.toLowerCase() === "skill.md" && parts.length > 1) {
|
|
return parts[parts.length - 2];
|
|
}
|
|
return fileName.replace(/\.[^.]+$/, "");
|
|
}
|
|
|
|
function parseFolderList(value: string): string[] {
|
|
return value
|
|
.split(",")
|
|
.map((folder) => folder.trim().replace(/^\/+/, ""))
|
|
.filter(Boolean);
|
|
}
|
|
|
|
class ContextBudget {
|
|
private remainingChars: number;
|
|
|
|
constructor(maxChars: number) {
|
|
this.remainingChars = maxChars;
|
|
}
|
|
|
|
hasRoom(): boolean {
|
|
return this.remainingChars > 0;
|
|
}
|
|
|
|
remaining(): number {
|
|
return this.remainingChars;
|
|
}
|
|
|
|
take(content: string): string {
|
|
const clipped = content.slice(0, this.remainingChars);
|
|
this.remainingChars -= clipped.length;
|
|
return clipped;
|
|
}
|
|
}
|
|
|
|
function buildAgentInstructions(accessMode: AccessMode): string {
|
|
return [
|
|
"You are running inside an Obsidian AI Sidebar plugin.",
|
|
"Use the provided vault context to answer the user.",
|
|
"If the prompt contains slash commands such as /writer or /reviewer, apply the matching selectedSkills instructions from the request context.",
|
|
"The request may include conversation memory and per-request options such as model or reasoning effort.",
|
|
"When you need file changes, include a JSON code block with this shape:",
|
|
'{"actions":[{"type":"edit","path":"Note.md","content":"new content"}]}',
|
|
"Allowed action types: create, edit, append, delete, rename.",
|
|
`Current access mode: ${accessMode}. The plugin enforces this mode before applying actions.`,
|
|
].join("\n");
|
|
}
|
|
|
|
async function runProvider(provider: AgentProvider, request: AgentRequest, app: App): Promise<string> {
|
|
if (provider.authType === "api-key") {
|
|
return runOpenAICompatibleProvider(provider, request);
|
|
}
|
|
|
|
if (provider.authType === "oauth") {
|
|
if (!provider.accessToken) {
|
|
throw new Error("This OAuth provider is not connected yet.");
|
|
}
|
|
return runOAuthProvider(provider, request);
|
|
}
|
|
|
|
return runCliProvider(provider, request, app);
|
|
}
|
|
|
|
async function runOpenAICompatibleProvider(provider: AgentProvider, request: AgentRequest): Promise<string> {
|
|
if (!provider.apiKey) throw new Error("Missing API key.");
|
|
const url = provider.apiBaseUrl || "https://api.openai.com/v1/responses";
|
|
const model = request.options.model || provider.model || "gpt-4.1-mini";
|
|
const userPayload = JSON.stringify({
|
|
prompt: request.prompt,
|
|
accessMode: request.accessMode,
|
|
context: request.context,
|
|
options: request.options,
|
|
});
|
|
const messages = [
|
|
{ role: "system", content: request.instructions },
|
|
...request.conversation.map((message) => ({
|
|
role: message.role === "assistant" ? "assistant" : "user",
|
|
content: message.content,
|
|
})),
|
|
{ role: "user", content: userPayload },
|
|
];
|
|
const usesChatCompletions = url.includes("/chat/completions");
|
|
const body: Record<string, unknown> = usesChatCompletions
|
|
? { model, messages }
|
|
: { model, input: messages };
|
|
if (request.options.reasoningEffort && model.startsWith("o")) {
|
|
body.reasoning = { effort: request.options.reasoningEffort };
|
|
}
|
|
const response = await requestUrl({
|
|
url,
|
|
method: "POST",
|
|
headers: {
|
|
"Authorization": `Bearer ${provider.apiKey}`,
|
|
"Content-Type": "application/json",
|
|
},
|
|
body: JSON.stringify(body),
|
|
throw: false,
|
|
});
|
|
|
|
if (response.status < 200 || response.status >= 300) {
|
|
throw new Error(response.text || `HTTP ${response.status}`);
|
|
}
|
|
|
|
return extractOpenAIText(response.json);
|
|
}
|
|
|
|
async function runOAuthProvider(provider: AgentProvider, request: AgentRequest): Promise<string> {
|
|
if (!provider.apiBaseUrl) {
|
|
throw new Error("OAuth provider needs an API endpoint after login.");
|
|
}
|
|
const response = await requestUrl({
|
|
url: provider.apiBaseUrl,
|
|
method: "POST",
|
|
headers: {
|
|
"Authorization": `Bearer ${provider.accessToken}`,
|
|
"Content-Type": "application/json",
|
|
},
|
|
body: JSON.stringify(request),
|
|
throw: false,
|
|
});
|
|
|
|
if (response.status < 200 || response.status >= 300) {
|
|
throw new Error(response.text || `HTTP ${response.status}`);
|
|
}
|
|
|
|
const responseJson = response.json as { text?: unknown; output_text?: unknown } | undefined;
|
|
if (typeof responseJson?.text === "string") return responseJson.text;
|
|
if (typeof responseJson?.output_text === "string") return responseJson.output_text;
|
|
return response.text;
|
|
}
|
|
|
|
function runCliProvider(provider: AgentProvider, request: AgentRequest, app: App): Promise<string> {
|
|
return new Promise((resolve, reject) => {
|
|
const prompt = cliPromptFromRequest(request);
|
|
const command = cliCommandForRequest(provider, request, app);
|
|
const shellCommand = `${command} ${shellQuote(prompt)}`;
|
|
const child = spawn("/bin/zsh", ["-lc", shellCommand], {
|
|
stdio: ["ignore", "pipe", "pipe"],
|
|
});
|
|
|
|
let stdout = "";
|
|
let stderr = "";
|
|
|
|
child.stdout.on("data", (chunk: Buffer) => {
|
|
stdout += chunk.toString();
|
|
});
|
|
|
|
child.stderr.on("data", (chunk: Buffer) => {
|
|
stderr += chunk.toString();
|
|
});
|
|
|
|
child.on("error", reject);
|
|
child.on("close", (code) => {
|
|
if (code === 0) {
|
|
resolve(stdout.trim());
|
|
} else {
|
|
reject(new Error(stderr.trim() || `Command exited with code ${code}. Check that ${command} is installed and available in your shell.`));
|
|
}
|
|
});
|
|
|
|
});
|
|
}
|
|
|
|
function cliCommandForRequest(provider: AgentProvider, request: AgentRequest, app: App): string {
|
|
const vaultPath = getVaultPath(app);
|
|
if (provider.id === "codex" || provider.command.startsWith("codex exec")) {
|
|
const sandbox = providerSandboxForAccessMode(request.accessMode);
|
|
const cdArg = vaultPath ? ` -C ${shellQuote(vaultPath)}` : "";
|
|
return `${provider.command}${cdArg} --skip-git-repo-check -s ${sandbox}`;
|
|
}
|
|
return provider.command;
|
|
}
|
|
|
|
function providerSandboxForAccessMode(accessMode: AccessMode): string {
|
|
if (accessMode === "full-access") return "workspace-write";
|
|
return "read-only";
|
|
}
|
|
|
|
function getVaultPath(app: App): string | undefined {
|
|
const adapter = app.vault.adapter;
|
|
if ("basePath" in adapter && typeof adapter.basePath === "string") {
|
|
return adapter.basePath;
|
|
}
|
|
return undefined;
|
|
}
|
|
|
|
function cliPromptFromRequest(request: AgentRequest): string {
|
|
return [
|
|
request.instructions,
|
|
"",
|
|
"User request:",
|
|
request.prompt,
|
|
"",
|
|
"Vault context and options:",
|
|
JSON.stringify({
|
|
accessMode: request.accessMode,
|
|
options: request.options,
|
|
conversation: request.options.memoryEnabled ? request.conversation : [],
|
|
context: request.context,
|
|
}, null, 2),
|
|
].join("\n");
|
|
}
|
|
|
|
function openInteractiveTerminal(command: string, title: string): Promise<void> {
|
|
const escapedCommand = escapeForSingleQuotedShell(command);
|
|
const script = [
|
|
`tell application "Terminal"`,
|
|
"activate",
|
|
`do script "printf '\\\\033]0;${escapeForAppleScript(title)}\\\\007'; clear; echo 'AI Sidebar sign-in'; echo ''; echo 'Running: ${escapeForAppleScript(command)}'; echo ''; /bin/zsh -lc '${escapedCommand}; echo; echo Sign-in command finished. You can close this window when done.'"`
|
|
,
|
|
"end tell",
|
|
].join("\n");
|
|
|
|
return new Promise((resolve, reject) => {
|
|
const child = spawn("osascript", ["-e", script], {
|
|
stdio: ["ignore", "ignore", "pipe"],
|
|
});
|
|
let stderr = "";
|
|
child.stderr.on("data", (chunk: Buffer) => {
|
|
stderr += chunk.toString();
|
|
});
|
|
child.on("error", reject);
|
|
child.on("close", (code) => {
|
|
if (code === 0) resolve();
|
|
else reject(new Error(stderr.trim() || `Could not open Terminal. Exit code ${code}`));
|
|
});
|
|
});
|
|
}
|
|
|
|
function extractOpenAIText(json: unknown): string {
|
|
if (!json || typeof json !== "object") return "";
|
|
const response = json as {
|
|
output_text?: string;
|
|
output?: Array<{ content?: Array<{ text?: string; type?: string }> }>;
|
|
choices?: Array<{ message?: { content?: string } }>;
|
|
};
|
|
if (typeof response.output_text === "string") return response.output_text;
|
|
if (typeof response.choices?.[0]?.message?.content === "string") {
|
|
return response.choices[0].message.content;
|
|
}
|
|
const parts: string[] = [];
|
|
for (const item of response.output ?? []) {
|
|
for (const content of item.content ?? []) {
|
|
if (typeof content.text === "string") parts.push(content.text);
|
|
}
|
|
}
|
|
return parts.join("\n");
|
|
}
|
|
|
|
function startOAuthLogin(provider: AgentProvider): boolean {
|
|
if (!provider.authorizationUrl || !provider.clientId) {
|
|
new Notice("Add an authorization URL and client ID first.");
|
|
return false;
|
|
}
|
|
|
|
const url = new URL(provider.authorizationUrl);
|
|
url.searchParams.set("response_type", "token");
|
|
url.searchParams.set("client_id", provider.clientId);
|
|
url.searchParams.set("redirect_uri", "urn:ietf:wg:oauth:2.0:oob");
|
|
if (provider.scope) url.searchParams.set("scope", provider.scope);
|
|
url.searchParams.set("state", crypto.randomUUID());
|
|
|
|
window.open(url.toString());
|
|
new Notice("OAUTH sign-in opened in your browser. Paste the returned token into this provider when available.");
|
|
return true;
|
|
}
|
|
|
|
async function startProviderSignIn(provider: AgentProvider): Promise<boolean> {
|
|
if (provider.authType === "cli") {
|
|
if (!provider.signInCommand) {
|
|
new Notice("This local provider does not have a sign-in command configured.");
|
|
return false;
|
|
}
|
|
try {
|
|
await openInteractiveTerminal(provider.signInCommand, `${provider.name} Sign In`);
|
|
new Notice(`Opened Terminal for ${provider.name} sign-in.`);
|
|
return true;
|
|
} catch (error) {
|
|
const message = error instanceof Error ? error.message : String(error);
|
|
new Notice(`Could not open sign-in: ${message}`);
|
|
return false;
|
|
}
|
|
}
|
|
|
|
if (provider.authType === "api-key") {
|
|
if (provider.setupUrl) window.open(provider.setupUrl);
|
|
new Notice(provider.apiKey ? `${provider.name} is connected.` : `Add your ${provider.name} API key below to connect.`);
|
|
return Boolean(provider.apiKey);
|
|
}
|
|
|
|
return startOAuthLogin(provider);
|
|
}
|
|
|
|
function escapeForSingleQuotedShell(value: string): string {
|
|
return value.replace(/'/g, "'\\''");
|
|
}
|
|
|
|
function shellQuote(value: string): string {
|
|
return `'${escapeForSingleQuotedShell(value)}'`;
|
|
}
|
|
|
|
function escapeForAppleScript(value: string): string {
|
|
return value.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
|
|
}
|
|
|
|
function providerConnectionActionText(provider: AgentProvider): string {
|
|
if (provider.authType === "cli") return isProviderConnected(provider) ? "Reconnect" : "Sign in";
|
|
if (provider.authType === "api-key") return provider.apiKey ? "Connected" : "Get key";
|
|
return provider.accessToken ? "Reconnect" : "Sign in";
|
|
}
|
|
|
|
function providerConnectionLabel(provider: AgentProvider): string {
|
|
if (isProviderConnected(provider)) return "Connected";
|
|
if (provider.authType === "api-key") return "Needs API key";
|
|
if (provider.authType === "oauth") return "Needs sign-in";
|
|
return provider.signInCommand ? "Ready to sign in" : "Needs command";
|
|
}
|
|
|
|
function isProviderConnected(provider: AgentProvider): boolean {
|
|
if (provider.authType === "api-key") return Boolean(provider.apiKey);
|
|
if (provider.authType === "oauth") return Boolean(provider.accessToken);
|
|
return Boolean(provider.connectedAt);
|
|
}
|
|
|
|
function isProviderReady(provider: AgentProvider): boolean {
|
|
if (provider.authType === "api-key") return Boolean(provider.apiKey && provider.apiBaseUrl);
|
|
if (provider.authType === "oauth") return Boolean(provider.accessToken && provider.apiBaseUrl);
|
|
return Boolean(provider.command.trim());
|
|
}
|
|
|
|
function normalizeProviders(providers: AgentProvider[]): AgentProvider[] {
|
|
return providers.map((provider) => {
|
|
const command = provider.id === "codex" && provider.command === "codex"
|
|
? "codex exec"
|
|
: provider.command ?? "";
|
|
return {
|
|
...provider,
|
|
authType: provider.authType ?? (provider.command ? "cli" : "api-key"),
|
|
command,
|
|
connectedAt: provider.connectedAt,
|
|
};
|
|
});
|
|
}
|
|
|
|
function cloneProvider(provider: AgentProvider): AgentProvider {
|
|
return { ...provider };
|
|
}
|
|
|
|
function extractVaultActions(response: string): VaultAction[] {
|
|
const actions: VaultAction[] = [];
|
|
const codeBlockPattern = /```(?:json)?\s*([\s\S]*?)```/gi;
|
|
const candidates: string[] = [];
|
|
let match: RegExpExecArray | null;
|
|
|
|
while ((match = codeBlockPattern.exec(response)) !== null) {
|
|
candidates.push(match[1]);
|
|
}
|
|
candidates.push(response);
|
|
|
|
for (const candidate of candidates) {
|
|
try {
|
|
const parsed = JSON.parse(candidate.trim()) as { actions?: VaultAction[] };
|
|
if (Array.isArray(parsed.actions)) {
|
|
actions.push(...parsed.actions.filter(isVaultAction));
|
|
}
|
|
} catch {
|
|
continue;
|
|
}
|
|
}
|
|
|
|
return actions;
|
|
}
|
|
|
|
function isVaultAction(value: unknown): value is VaultAction {
|
|
if (!value || typeof value !== "object") return false;
|
|
const action = value as Partial<VaultAction>;
|
|
if (typeof action.type !== "string" || typeof action.path !== "string") return false;
|
|
if (["create", "edit", "append"].includes(action.type)) {
|
|
return typeof (action as { content?: unknown }).content === "string";
|
|
}
|
|
if (action.type === "delete") return true;
|
|
if (action.type === "rename") {
|
|
return typeof (action as { newPath?: unknown }).newPath === "string";
|
|
}
|
|
return false;
|
|
}
|
|
|
|
function confirmVaultActions(app: App, actions: VaultAction[]): Promise<boolean> {
|
|
return new Promise((resolve) => {
|
|
new ConfirmActionsModal(app, actions, resolve).open();
|
|
});
|
|
}
|
|
|
|
async function applyVaultAction(app: App, action: VaultAction): Promise<void> {
|
|
const path = normalizeVaultPath(action.path);
|
|
const file = app.vault.getAbstractFileByPath(path);
|
|
|
|
if (action.type === "create") {
|
|
if (file) throw new Error("File already exists.");
|
|
await ensureParentFolder(app, path);
|
|
await app.vault.create(path, action.content);
|
|
return;
|
|
}
|
|
|
|
if (!(file instanceof TFile)) {
|
|
throw new Error("File does not exist.");
|
|
}
|
|
|
|
if (action.type === "edit") {
|
|
await app.vault.modify(file, action.content);
|
|
} else if (action.type === "append") {
|
|
const current = await app.vault.read(file);
|
|
await app.vault.modify(file, `${current}${current.endsWith("\n") ? "" : "\n"}${action.content}`);
|
|
} else if (action.type === "delete") {
|
|
await app.fileManager.trashFile(file);
|
|
} else if (action.type === "rename") {
|
|
await ensureParentFolder(app, action.newPath);
|
|
await app.fileManager.renameFile(file, normalizeVaultPath(action.newPath));
|
|
}
|
|
}
|
|
|
|
async function ensureParentFolder(app: App, path: string): Promise<void> {
|
|
const parts = normalizeVaultPath(path).split("/");
|
|
parts.pop();
|
|
let current = "";
|
|
for (const part of parts) {
|
|
current = current ? `${current}/${part}` : part;
|
|
if (!app.vault.getAbstractFileByPath(current)) {
|
|
await app.vault.createFolder(current);
|
|
}
|
|
}
|
|
}
|
|
|
|
function normalizeVaultPath(path: string): string {
|
|
return path.replace(/^\/+/, "").replace(/\\/g, "/");
|
|
}
|
|
|
|
function uniqueFiles(files: TFile[]): TFile[] {
|
|
const seen = new Set<string>();
|
|
return files.filter((file) => {
|
|
if (seen.has(file.path)) return false;
|
|
seen.add(file.path);
|
|
return true;
|
|
});
|
|
}
|
|
|
|
function isReasoningEffort(value: string): value is ReasoningEffort {
|
|
return value === "low" || value === "medium" || value === "high";
|
|
}
|
|
|
|
function isAccessMode(value: string): value is AccessMode {
|
|
return value === "read-only" || value === "confirm" || value === "full-access";
|
|
}
|
|
|
|
function escapeRegExp(value: string): string {
|
|
return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
|
|
}
|