@lapis-notes/api 0.1.0

package/dist/plugin.js

@@ -0,0 +1,754 @@
+import { matchesProjectionSource } from "./storage/index-projection";
+import { dirname, joinPath } from "./storage";
+import { Component } from "./view.svelte";
+function isPromiseLike(value) {
+    return typeof value?.then === "function";
+}
+/**
+ * Resolve the compatibility data path used by `loadData()` and `saveData()`.
+ *
+ * Community plugins store data beside their manifest folder, while bundled and
+ * system plugins use the shared `/.obsidian/<id>.json` location.
+ *
+ * @public
+ */
+export function resolvePluginDataPath(pluginId, source, basePath) {
+    if (source === "core" || source === "system") {
+        return joinPath("/.obsidian", `${pluginId}.json`);
+    }
+    if (!basePath) {
+        return null;
+    }
+    return joinPath(basePath, "data.json");
+}
+function formatPluginError(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+/**
+ * Base class for Lapis plugins.
+ *
+ * Plugins extend {@link Component}, so teardown callbacks, events, commands, and
+ * DOM listeners registered through helper methods are cleaned up when the
+ * plugin unloads.
+ *
+ * @public
+ */
+export class Plugin extends Component {
+    app;
+    manifest;
+    basePath = "";
+    #runtimeState = "disabled";
+    #failureMessage = null;
+    #lastFailureMessage = null;
+    #failureCount = 0;
+    #source = "community";
+    #provenance = "community";
+    #required = false;
+    #hostMode = "renderer";
+    #registeredViewTypes = new Set();
+    #requestedCapabilities = [];
+    #grantedCapabilities = [];
+    constructor(app, manifest) {
+        super();
+        this.app = app;
+        this.manifest = manifest;
+    }
+    /**
+     * Release plugin-owned resources before the plugin unloads.
+     *
+     * @public
+     */
+    onunload() { }
+    /**
+     * Apply runtime metadata resolved by the plugin manager before activation.
+     *
+     * @param options - Runtime source, host, and capability information.
+     * @public
+     */
+    configureRuntime(options = {}) {
+        if (options.basePath !== undefined) {
+            this.basePath = options.basePath;
+        }
+        if (options.source) {
+            this.#source = options.source;
+            this.#provenance = defaultPluginProvenance(options.source);
+        }
+        if (options.provenance) {
+            this.#provenance = options.provenance;
+        }
+        if (options.required !== undefined) {
+            this.#required = options.required;
+        }
+        if (options.hostMode !== undefined) {
+            this.#hostMode = options.hostMode;
+        }
+        if (options.requestedCapabilities !== undefined) {
+            this.#requestedCapabilities = [...options.requestedCapabilities];
+        }
+        if (options.grantedCapabilities !== undefined) {
+            this.#grantedCapabilities = [...options.grantedCapabilities];
+        }
+    }
+    /**
+     * Enable the plugin and run its `onload()` lifecycle.
+     *
+     * @returns A promise that resolves when activation completes.
+     * @public
+     */
+    async enable() {
+        if (!this.app.plugins.plugins.has(this.id)) {
+            this.app.plugins.plugins.set(this.id, this);
+        }
+        if (this.enabled)
+            return;
+        this.#runtimeState = "enabling";
+        this.#failureMessage = null;
+        try {
+            if ((this.source === "community" || this.source === "official") &&
+                this.manifest.lapis?.database?.metadataAccess !== "queries") {
+                const lease = await this.app.metadataCache.acquireMetadataSnapshotLease();
+                this.register(() => lease.release());
+            }
+            await this.loadAsync();
+            this.#runtimeState = "enabled";
+            this.emit("enable");
+        }
+        catch (error) {
+            this.#runtimeState = "failed";
+            this.#failureMessage = formatPluginError(error);
+            this.#lastFailureMessage = this.#failureMessage;
+            this.#failureCount += 1;
+            throw error;
+        }
+    }
+    get enabled() {
+        return this.#runtimeState === "enabled";
+    }
+    get source() {
+        return this.#source;
+    }
+    get provenance() {
+        return this.#provenance;
+    }
+    get required() {
+        return this.#required;
+    }
+    /** View types owned by this plugin across enable and disable cycles. */
+    get registeredViewTypes() {
+        return this.#registeredViewTypes;
+    }
+    get state() {
+        return this.#runtimeState;
+    }
+    get errorMessage() {
+        return this.#failureMessage;
+    }
+    get lastFailureMessage() {
+        return this.#lastFailureMessage;
+    }
+    get failureCount() {
+        return this.#failureCount;
+    }
+    get hostMode() {
+        return this.#hostMode;
+    }
+    get requestedCapabilities() {
+        return [...this.#requestedCapabilities];
+    }
+    get grantedCapabilities() {
+        return [...this.#grantedCapabilities];
+    }
+    get id() {
+        return this.manifest.id;
+    }
+    getDataPath() {
+        return resolvePluginDataPath(this.manifest.id, this.source, this.basePath);
+    }
+    async readLegacyData() {
+        const path = this.getDataPath();
+        if (!path) {
+            return null;
+        }
+        const file = this.app.vault.getFileByPath(path);
+        if (!file) {
+            return null;
+        }
+        return JSON.parse(await this.app.vault.read(file));
+    }
+    async writeLegacyData(data) {
+        const path = this.getDataPath();
+        if (!path) {
+            return;
+        }
+        const payload = JSON.stringify(data, null, 2);
+        const file = this.app.vault.getFileByPath(path);
+        if (file) {
+            await this.app.vault.modify(file, payload);
+            return;
+        }
+        await this.app.vault.mkpath(dirname(path));
+        await this.app.vault.create(path, payload);
+    }
+    telemetryAttributes(attributes = {}) {
+        return {
+            "plugin.id": this.manifest.id,
+            "plugin.name": this.manifest.name,
+            "plugin.source": this.source,
+            ...attributes,
+        };
+    }
+    startTelemetrySpan(name, options = {}) {
+        return this.app.telemetry.startSpan(name, {
+            ...options,
+            attributes: this.telemetryAttributes(options.attributes),
+        });
+    }
+    measureTelemetry(name, callback, options = {}) {
+        return this.app.telemetry.measure(name, callback, {
+            ...options,
+            attributes: this.telemetryAttributes(options.attributes),
+        });
+    }
+    measureTelemetryAsync(name, callback, options = {}) {
+        return this.app.telemetry.measureAsync(name, callback, {
+            ...options,
+            attributes: this.telemetryAttributes(options.attributes),
+        });
+    }
+    async disable() {
+        if (!this.loaded) {
+            this.#runtimeState = "disabled";
+            this.#failureMessage = null;
+            return;
+        }
+        this.#runtimeState = "disabling";
+        try {
+            await this.unloadAsync();
+            this.#runtimeState = "disabled";
+            this.#failureMessage = null;
+            this.emit("disable");
+        }
+        catch (error) {
+            this.#runtimeState = "failed";
+            this.#failureMessage = formatPluginError(error);
+            this.#lastFailureMessage = this.#failureMessage;
+            this.#failureCount += 1;
+            throw error;
+        }
+    }
+    addStatusBarItem() {
+        let parent = this.app.workspace.statusCompatEl ??
+            document.querySelector("#status-bar");
+        if (!parent) {
+            parent = document.querySelector("#lapis-status-bar-compat-fallback");
+        }
+        if (!parent) {
+            parent = document.body.createDiv({
+                attr: {
+                    id: "lapis-status-bar-compat-fallback",
+                    hidden: "true",
+                    "aria-hidden": "true",
+                },
+            });
+        }
+        this.app.workspace.statusCompatEl = parent;
+        const statusEl = parent.createDiv({
+            cls: "status-bar-item plugin-" + this.manifest.id,
+        });
+        this.register(() => {
+            statusEl.detach();
+        });
+        return statusEl;
+    }
+    /**
+     * Load settings data from disk. Data is stored in `data.json` in the plugin
+     * folder.
+     *
+     * @public
+     * @see {@link https://docs.obsidian.md/Plugins/User+interface/Settings}
+     */
+    loadData() {
+        return this.measureTelemetryAsync("plugin.load_data", async () => {
+            if (this.app.configuration.hasPluginData(this.id)) {
+                const data = this.app.configuration.getPluginData(this.id);
+                await this.writeLegacyData(data);
+                return data;
+            }
+            const legacyData = await this.readLegacyData();
+            if (legacyData !== null) {
+                await this.app.configuration.updatePluginData(this.id, legacyData);
+            }
+            return legacyData;
+        });
+    }
+    /**
+     * Write settings data to disk. Data is stored in `data.json` in the plugin
+     * folder.
+     *
+     * @public
+     * @see {@link https://docs.obsidian.md/Plugins/User+interface/Settings}
+     */
+    saveData(data) {
+        return this.measureTelemetryAsync("plugin.save_data", async () => {
+            await this.app.configuration.updatePluginData(this.id, data, {
+                origin: "plugin-save",
+            });
+            await this.writeLegacyData(data);
+        });
+    }
+    async loadGeneratedState(key) {
+        return ((await this.app.appDatabase.getMeta(this.generatedStateMetaKey(this.requireGeneratedStateKey(key)))) ?? null);
+    }
+    async saveGeneratedState(key, value) {
+        await this.app.appDatabase.setMeta(this.generatedStateMetaKey(this.requireGeneratedStateKey(key)), value);
+    }
+    async deleteGeneratedState(key) {
+        await this.app.appDatabase.setMeta(this.generatedStateMetaKey(this.requireGeneratedStateKey(key)), undefined);
+    }
+    async migrateDataToGeneratedState(legacyKey, options = {}) {
+        const sourceKey = this.requireGeneratedStateKey(legacyKey);
+        const generatedKey = this.requireGeneratedStateKey(options.generatedKey ?? legacyKey);
+        const migrationMetaKey = this.generatedStateMigrationMetaKey(sourceKey);
+        const existing = await this.loadGeneratedState(generatedKey);
+        if (existing !== null) {
+            await this.saveGeneratedState(migrationMetaKey, true);
+            return existing;
+        }
+        const migrated = (await this.app.appDatabase.getMeta(migrationMetaKey)) === true;
+        if (migrated) {
+            return null;
+        }
+        const data = await this.loadData();
+        if (!data || typeof data !== "object") {
+            await this.saveGeneratedState(migrationMetaKey, true);
+            return null;
+        }
+        const record = data;
+        if (!(sourceKey in record)) {
+            await this.saveGeneratedState(migrationMetaKey, true);
+            return null;
+        }
+        const value = (record[sourceKey] ?? null);
+        await this.saveGeneratedState(generatedKey, value);
+        await this.saveGeneratedState(migrationMetaKey, true);
+        if (options.pruneLegacyKey) {
+            const next = { ...record };
+            delete next[sourceKey];
+            await this.saveData(next);
+        }
+        return value;
+    }
+    requireGeneratedStateKey(key) {
+        const normalized = key.trim();
+        if (!normalized) {
+            throw new Error("Generated state key must not be empty");
+        }
+        return normalized;
+    }
+    generatedStateMetaKey(key) {
+        return `plugin.generated:${this.manifest.id}:${key}`;
+    }
+    generatedStateMigrationMetaKey(key) {
+        return `plugin.generated:${this.manifest.id}:__migrated__:${key}`;
+    }
+    addRibbonIcon(icon, title, callback) {
+        const id = `${this.manifest.id}:${title}`;
+        this.register(this.app.workspace.leftRibbon.addItem({
+            id,
+            title,
+            hidden: false,
+            callback,
+            icon,
+        }));
+    }
+    addCommand(command) {
+        command.sourcePlugin ??= this.manifest.id;
+        command.title ??= command.name;
+        if (!["app"].includes(this.manifest.id)) {
+            let prefix = `${this.manifest.id}:`;
+            if (!command.id.startsWith(prefix)) {
+                command.id = prefix + command.id;
+            }
+            prefix = `${this.manifest.name}:`;
+            if (!command.name.startsWith(prefix)) {
+                command.name = prefix + " " + command.name;
+            }
+        }
+        this.app.commands.registerCommand(command);
+        this.register(() => {
+            this.app.commands.unregisterCommand(command.id);
+        });
+        return command;
+    }
+    removeCommand(commandId) {
+        this.app.commands.unregisterCommand(commandId);
+    }
+    registerContextKey(key, defaultValue) {
+        const handle = this.app.contextKeys.createScopedKey(`plugin.${this.manifest.id}`, key, defaultValue);
+        this.register(() => {
+            handle.reset();
+        });
+        return handle;
+    }
+    registerShortcut(handler) {
+        this.register(() => handler.scope.unregister(handler));
+    }
+    registerView(type, viewCreator, access) {
+        this.#registeredViewTypes.add(type);
+        const instrumentedViewCreator = (leaf) => this.measureTelemetry("plugin.view.create", () => viewCreator(leaf), {
+            attributes: { "view.type": type },
+            slowThresholdMs: 50,
+        });
+        this.app.workspace.registerView(type, instrumentedViewCreator);
+        this.register(() => {
+            this.app.workspace.unregisterView(type);
+        });
+        if (access?.kind === "command") {
+            this.addCommand(access.command);
+        }
+    }
+    registerSidebarView(type, viewCreator, options = {}, access) {
+        this.registerView(type, viewCreator, access);
+        this.app.workspace.registerSidebarView(type, options);
+        this.register(() => {
+            this.app.workspace.unregisterSidebarView(type);
+        });
+    }
+    registerEditorView(contribution) {
+        const dispose = this.app.workspace.registerEditorView({
+            ...contribution,
+            pluginId: contribution.pluginId ?? this.manifest.id,
+            source: contribution.source ?? "plugin",
+        });
+        this.register(dispose);
+    }
+    registerConfigurationOptionSource(id, provider) {
+        const sourceId = id.includes(".") || id.includes(":") ? id : `${this.manifest.id}.${id}`;
+        const registration = this.app.configurationOptionSources.register(sourceId, {
+            ...provider,
+            pluginId: this.manifest.id,
+        });
+        this.register(registration.dispose);
+        return registration;
+    }
+    registerHoverLinkSource(id, info) {
+        this.app.workspace.registerHoverLinkSource(id, info);
+        this.register(() => {
+            this.app.workspace.unregisterHoverLinkSource(id);
+        });
+    }
+    registerObsidianProtocolHandler(action, handler) {
+        const dispose = this.app.urls.registerProtocolHandler(action, handler);
+        this.register(dispose);
+    }
+    registerCliHandler(name, prefix, callback) {
+        this.register(() => { });
+    }
+    registerBasesView(viewId, registration) {
+        const registered = this.app.plugins.registerBasesView(this.manifest.id, viewId, registration);
+        if (registered) {
+            this.register(() => {
+                this.app.plugins.unregisterBasesView(this.manifest.id, viewId);
+            });
+        }
+        return registered;
+    }
+    registerLapisServiceProvider(registration) {
+        const disposer = this.app.plugins.registerLapisServiceProvider({
+            ...registration,
+            pluginId: this.manifest.id,
+        });
+        this.register(disposer);
+    }
+    /** Create an owner-scoped diagnostic collection disposed with this plugin. */
+    createDiagnosticCollection(id, options = {}) {
+        const collection = this.app.workspace.diagnostics.createCollection(`plugin:${this.manifest.id}:${id}`, options);
+        this.register(() => collection.dispose());
+        return collection;
+    }
+    onUserEnable() { }
+    onExternalSettingsChange() { }
+    registerExtensions(extensions, viewType = "markdown") {
+        this.app.workspace.registerExtensions(extensions, viewType);
+        this.register(() => {
+            this.app.workspace.unregisterExtensions(extensions, viewType);
+        });
+    }
+    registerTypeWidget(widget) {
+        const existing = this.app.metadataTypeManager.registeredTypeWidgets[widget.type];
+        this.app.metadataTypeManager.registerTypeWidget(widget);
+        this.register(() => {
+            this.app.metadataTypeManager.unregisterTypeWidget(widget);
+            if (existing) {
+                this.app.metadataTypeManager.registerTypeWidget(existing);
+            }
+        });
+    }
+    /**
+     * Register an EditorSuggest which can provide live suggestions while the user
+     * is typing.
+     *
+     * @public
+     */
+    registerEditorSuggest(editorSuggest, viewType = "markdown") {
+        this.app.registerEditorSuggest(editorSuggest, viewType);
+        this.register(() => {
+            this.app.unregisterEditorSuggest(editorSuggest, viewType);
+        });
+    }
+    /**
+     * Registers a CodeMirror 6 extension. To reconfigure cm6 extensions for a
+     * plugin on the fly, an array should be passed in, and modified dynamically.
+     * Once this array is modified, calling {@link Workspace.updateOptions} will
+     * apply the changes.
+     *
+     * @param extension - Must be a CodeMirror 6 `Extension`, or an array of
+     *   Extensions.
+     * @public
+     */
+    registerEditorExtension(extension, viewType) {
+        this.app.registerEditorExtension(extension, viewType);
+        this.register(() => {
+            this.app.unregisterEditorExtension(extension, viewType);
+        });
+    }
+    /** Register a plugin-owned Markdown contribution for every Markdown surface. */
+    registerMarkdownExtension(contribution) {
+        this.register(this.app.markdownExtensions.register(this.id, contribution));
+    }
+    /** Register a provider for complete Markdown file surfaces. */
+    registerMarkdownFileSurfaceProvider(provider) {
+        this.register(this.app.markdownFileSurfaces.register(this.id, provider));
+    }
+    /**
+     * Registers a post processor, to change how the document looks in reading
+     * mode.
+     *
+     * @public
+     * @see {@link https://docs.obsidian.md/Plugins/Editor/Markdown+post+processing}
+     */
+    registerMarkdownPostProcessor(postProcessor, sortOrder) {
+        postProcessor.sortOrder = sortOrder ?? postProcessor.sortOrder ?? 0;
+        const wrappedPostProcessor = (el, ctx) => {
+            const attributes = this.telemetryAttributes({
+                "plugin.processor.kind": "markdown-post-processor",
+                "plugin.processor.sort_order": postProcessor.sortOrder ?? 0,
+                "markdown.source_path": ctx.sourcePath,
+            });
+            const execute = () => postProcessor(el, ctx);
+            const result = execute();
+            if (isPromiseLike(result)) {
+                return this.app.telemetry.measureAsync("plugin.markdown_post_processor", async () => result, { attributes, slowThresholdMs: 50 });
+            }
+            return this.app.telemetry.measure("plugin.markdown_post_processor", () => result, { attributes, slowThresholdMs: 50 });
+        };
+        wrappedPostProcessor.sortOrder = postProcessor.sortOrder;
+        this.app.registerMarkdownPostProcessor(wrappedPostProcessor);
+        this.register(() => {
+            this.app.unregisterMarkdownPostProcessor(wrappedPostProcessor);
+        });
+        return wrappedPostProcessor;
+    }
+    registerMarkdownCodeBlockProcessor(language, handler, sortOrder) {
+        language = language.trim().toLocaleLowerCase();
+        const postProcessor = (el, ctx) => {
+            const source = ctx.getSectionInfo(el)?.text || "";
+            const execute = () => handler(source.replace(/^([`]{3}[^\n]*\n+)|\n+[`]{3}\n*$/g, ""), el, ctx);
+            const attributes = this.telemetryAttributes({
+                "plugin.processor.kind": "markdown-code-block-processor",
+                "plugin.processor.language": language,
+                "markdown.source_path": ctx.sourcePath,
+            });
+            const result = execute();
+            if (isPromiseLike(result)) {
+                return this.app.telemetry.measureAsync("plugin.markdown_code_block_processor", async () => result, { attributes, slowThresholdMs: 50 });
+            }
+            return this.app.telemetry.measure("plugin.markdown_code_block_processor", () => result, { attributes, slowThresholdMs: 50 });
+        };
+        postProcessor.sortOrder = sortOrder ?? postProcessor.sortOrder ?? 0;
+        this.app.registerMarkdownCodeBlockProcessor(language, postProcessor);
+        this.register(() => {
+            this.app.unregisterMarkdownCodeBlockProcessor(language, postProcessor);
+        });
+        return postProcessor;
+    }
+    registerMarkdownDirectiveRenderer(directive, renderer) {
+        this.app.registerMarkdownDirectiveRenderer(directive, renderer);
+        this.register(() => {
+            this.app.unregisterMarkdownDirectiveRenderer(directive);
+        });
+    }
+    registerMarkdownViewMenuItem(provider) {
+        this.app.registerMarkdownViewMenuItem(provider);
+        this.register(() => {
+            this.app.unregisterMarkdownViewMenuItem(provider);
+        });
+    }
+    registerMetadataProcessor(processor, ext = "md") {
+        this.app.metadataCache.addProcessor(ext, processor);
+        this.register(() => {
+            this.app.metadataCache.removeProcessor(ext, processor);
+        });
+    }
+    registerIndexProjection(registration) {
+        const recorded = this.app.indexProjections.register(this.id, registration);
+        void this.app.appDatabase.registerProjectionDefinition({
+            projectionId: recorded.projectionId,
+            ownerPluginId: this.id,
+            schemaVersion: registration.version,
+            configHash: registration.configurationHash ?? "",
+            visibility: registration.visibility ?? "public",
+            fields: registration.fields,
+            active: true,
+            updatedAt: Date.now(),
+        });
+        this.register(() => {
+            this.app.indexProjections.unregister(recorded.projectionId);
+            void this.app.appDatabase.unregisterProjectionDefinition(recorded.projectionId);
+        });
+        void this.backfillIndexProjection(recorded.projectionId);
+        return {
+            id: recorded.projectionId,
+            query: (query) => this.app.appDatabase.queryProjection(recorded.projectionId, query, this.id),
+            get: (id) => this.app.appDatabase.getProjectionRow(recorded.projectionId, id, this.id),
+            queryRelated: (query) => this.app.appDatabase.queryRelated({ ...query, projectionId: recorded.projectionId }, this.id),
+        };
+    }
+    async backfillIndexProjection(projectionId) {
+        const recorded = this.app.indexProjections.get(projectionId);
+        if (!recorded)
+            return;
+        const source = recorded.registration.source;
+        const candidates = await this.app.appDatabase.queryIndexedMetadata({
+            extensions: source?.extensions,
+            pathPrefixes: source?.pathPrefix ? [source.pathPrefix] : undefined,
+        });
+        for (const candidate of candidates) {
+            const file = this.app.vault.getFileByPath(candidate.file.path);
+            if (!file)
+                continue;
+            const cache = candidate.metadata?.metadata;
+            if (!matchesProjectionSource({ path: file.path, extension: file.extension, name: file.name }, cache, source)) {
+                continue;
+            }
+            try {
+                const content = await this.app.vault.cachedRead(file);
+                const result = await recorded.registration.project({
+                    file: { path: file.path, extension: file.extension, name: file.name },
+                    content,
+                    cache,
+                });
+                await this.app.appDatabase.replaceProjectionSource({
+                    projectionId,
+                    sourcePath: file.path,
+                    sourceHash: candidate.file.hash,
+                    rows: result.rows,
+                    edges: result.edges,
+                    writerPluginId: this.id,
+                });
+            }
+            catch (error) {
+                await this.app.appDatabase.markProjectionSourceError({
+                    projectionId,
+                    sourcePath: file.path,
+                    sourceHash: candidate.file.hash,
+                    error: error instanceof Error ? error.message : String(error),
+                    writerPluginId: this.id,
+                });
+            }
+        }
+    }
+    /**
+     * Contribute normalized searchable content without writing generated state.
+     * The local id is namespaced by this plugin's runtime id.
+     */
+    registerSearchDocumentProvider(localId, provider) {
+        const normalizedLocalId = localId.trim();
+        if (!normalizedLocalId) {
+            throw new Error("Search document provider local id must not be empty.");
+        }
+        const id = `${this.id}:${normalizedLocalId}`;
+        const registration = this.app.searchDocumentProviders.register({
+            ...provider,
+            id,
+        });
+        this.register(() => registration.dispose());
+        return registration;
+    }
+    /** Register an application tool under this plugin's lifecycle and identity. */
+    registerAgentTool(tool) {
+        const registration = this.app.agentTools.register({
+            pluginId: this.id,
+            source: this.source,
+            provenance: this.provenance,
+        }, tool);
+        this.register(() => registration.dispose());
+        return registration;
+    }
+    /** Register a directory that contains one skill. */
+    registerAgentSkillDirectory(path) {
+        const registration = this.app.agentSkills.registerDirectory({ pluginId: this.id }, path);
+        this.register(() => registration.dispose());
+        return registration;
+    }
+    /** Register a root that may contain many skill directories. */
+    registerAgentSkillRoot(path) {
+        const registration = this.app.agentSkills.registerRoot({ pluginId: this.id }, path);
+        this.register(() => registration.dispose());
+        return registration;
+    }
+    /** Register a programmatic skill under this plugin's lifecycle. */
+    registerAgentSkill(skill) {
+        const registration = this.app.agentSkills.registerSkill({ pluginId: this.id }, skill);
+        this.register(() => registration.dispose());
+        return registration;
+    }
+    /** Register a composer slash command. This is not a workspace palette command. */
+    registerAgentSlashCommand(command) {
+        const registration = this.app.agentSlashCommands.register({ pluginId: this.id }, command);
+        this.register(() => registration.dispose());
+        return registration;
+    }
+    /** Register a transcript result view. This is not a workspace palette command. */
+    registerAgentResultView(view) {
+        const registration = this.app.agentResultViews.register(this.id, view);
+        this.register(() => registration.dispose());
+        return registration;
+    }
+    /**
+     * Register a settings tab, which allows users to change settings.
+     *
+     * @public
+     * @see {@link https://docs.obsidian.md/Plugins/User+interface/Settings#Register+a+settings+tab}
+     */
+    addSettingTab(settingTab) {
+        if (this.source === "community" && !this.app.workspaceTrust.trusted) {
+            throw new Error(`Plugin ${this.manifest.id} cannot register settings while the workspace is untrusted`);
+        }
+        this.app.configuration.schema.registerWebView(settingTab.plugin.manifest.id, settingTab.plugin.manifest.name, settingTab);
+        this.register(() => {
+            this.app.configuration.schema.removeWebView(settingTab.plugin.manifest.id);
+        });
+        const setting = this.app.setting(this.source === "core" || this.source === "official"
+            ? "core-plugins"
+            : "community-plugins");
+        setting.addItem((opt) => opt
+            .setTitle(settingTab.plugin.manifest.name)
+            .setId(settingTab.plugin.manifest.id)
+            .setTab(settingTab));
+        this.register(() => {
+            setting.removeItem(settingTab.plugin.manifest.id);
+        });
+    }
+}
+function defaultPluginProvenance(source) {
+    switch (source) {
+        case "core":
+        case "system":
+            return "bundled";
+        case "official":
+            return "official";
+        default:
+            return "community";
+    }
+}