@lapis-notes/ai 0.1.0

package/dist/settings/ai-settings-tab.js

@@ -0,0 +1,249 @@
+import { PluginSettingTab, Setting, } from "@lapis-notes/api";
+import { ACP_AGENT_IDS } from "./acp-agents";
+import { applyAppToolEnablement } from "./ai-settings";
+import { listAppToolSettingRows, registeredAppToolRefs, } from "./app-tool-setting-rows";
+const ACP_AGENT_LABELS = {
+    codex: "Codex",
+    cursor: "Cursor",
+};
+const THINKING_OPTIONS = [
+    { id: "off", label: "Off" },
+    { id: "low", label: "Low" },
+    { id: "medium", label: "Medium" },
+    { id: "high", label: "High" },
+];
+export class AiSettingsTab extends PluginSettingTab {
+    aiPlugin;
+    constructor(app, aiPlugin) {
+        super(app, aiPlugin);
+        this.aiPlugin = aiPlugin;
+        const toolRegistryRef = this.app.agentTools.on("changed", () => {
+            if (this.containerEl?.isConnected)
+                this.display();
+        });
+        this.aiPlugin.register(() => this.app.agentTools.offref(toolRegistryRef));
+    }
+    display() {
+        const settings = this.aiPlugin.getSettings();
+        this.containerEl.empty();
+        new Setting(this.containerEl)
+            .setName("Default runtime")
+            .setDesc("Capability-based selection stays automatic unless you pin a runtime.")
+            .addDropdown((dropdown) => {
+            dropdown
+                .addOption("auto", "Automatic")
+                .addOption("acp", "ACP")
+                .addOption("codex-native", "Codex native")
+                .addOption("fake", "Fake (tests)")
+                .setValue(settings.defaultRuntime)
+                .onChange((value) => {
+                void this.aiPlugin.updateSettings({
+                    defaultRuntime: value,
+                });
+            });
+        });
+        new Setting(this.containerEl)
+            .setName("ACP agent")
+            .setDesc("Built-in ACP agent used when ACP is selected.")
+            .addDropdown((dropdown) => {
+            for (const id of ACP_AGENT_IDS) {
+                dropdown.addOption(id, ACP_AGENT_LABELS[id]);
+            }
+            dropdown.setValue(settings.acpAgent).onChange((value) => {
+                void this.aiPlugin
+                    .updateSettings({ acpAgent: value })
+                    .then(() => this.display());
+            });
+        });
+        const modelSetting = new Setting(this.containerEl)
+            .setName("Default model")
+            .setDesc("Models reported by the selected agent provider.");
+        modelSetting.addDropdown((dropdown) => {
+            dropdown
+                .setItems([
+                {
+                    value: settings.defaultModel || "__loading__",
+                    label: settings.defaultModel || "Loading models…",
+                    disabled: !settings.defaultModel,
+                },
+            ])
+                .setValue(settings.defaultModel || "__loading__")
+                .setDisabled(true);
+            void this.loadModels(dropdown, settings, modelSetting);
+        });
+        new Setting(this.containerEl)
+            .setName("Thinking")
+            .setDesc("How much model reasoning to request on each turn.")
+            .addDropdown((dropdown) => {
+            for (const option of THINKING_OPTIONS) {
+                dropdown.addOption(option.id, option.label);
+            }
+            dropdown.setValue(settings.thinking).onChange((value) => {
+                void this.aiPlugin.updateSettings({
+                    thinking: value,
+                });
+            });
+        });
+        new Setting(this.containerEl)
+            .setName("Automatic memory recall")
+            .setDesc("Inject up to three trusted curated memories into turns. Migrated vaults keep this off until enabled.")
+            .addToggle((toggle) => {
+            toggle.setValue(settings.memoryAutomaticRecall).onChange((value) => {
+                void this.aiPlugin.updateSettings({ memoryAutomaticRecall: value });
+            });
+        });
+        new Setting(this.containerEl)
+            .setName("Automatic memory consolidation")
+            .setDesc("Run bounded background proposals with a separately pinned processor. Enabling this may consume provider quota.")
+            .addToggle((toggle) => {
+            toggle
+                .setValue(settings.memoryConsolidationEnabled)
+                .onChange((value) => {
+                void this.aiPlugin.updateSettings({
+                    memoryConsolidationEnabled: value,
+                });
+            });
+        });
+        new Setting(this.containerEl)
+            .setName("Memory processor runtime")
+            .setDesc("Pinned independently from the interactive chat runtime.")
+            .addDropdown((dropdown) => {
+            dropdown
+                .addOption("acp", "ACP")
+                .addOption("codex-native", "Codex native")
+                .setValue(settings.memoryConsolidationRuntime)
+                .onChange((value) => {
+                void this.aiPlugin.updateSettings({
+                    memoryConsolidationRuntime: value === "codex-native" ? "codex-native" : "acp",
+                });
+            });
+        });
+        new Setting(this.containerEl)
+            .setName("Memory processor agent")
+            .setDesc("Pinned independently from the interactive chat agent.")
+            .addDropdown((dropdown) => {
+            for (const id of ACP_AGENT_IDS) {
+                dropdown.addOption(id, ACP_AGENT_LABELS[id]);
+            }
+            dropdown
+                .setValue(settings.memoryConsolidationAgent)
+                .onChange((value) => {
+                void this.aiPlugin.updateSettings({
+                    memoryConsolidationAgent: value,
+                });
+            });
+        });
+        new Setting(this.containerEl)
+            .setName("Memory processor model")
+            .setDesc("Exact model used only for restricted background consolidation.")
+            .addText((text) => {
+            text.setValue(settings.memoryConsolidationModel).onChange((value) => {
+                void this.aiPlugin.updateSettings({
+                    memoryConsolidationModel: value,
+                });
+            });
+        });
+        new Setting(this.containerEl)
+            .setName("Background handoff summaries")
+            .setDesc("Prepare verified summaries after long turns for future cross-agent switches. This is never run during a switch and may consume provider quota.")
+            .addToggle((toggle) => {
+            toggle.setValue(settings.handoffSummariesEnabled).onChange((value) => {
+                void this.aiPlugin.updateSettings({
+                    handoffSummariesEnabled: value,
+                });
+            });
+        });
+        new Setting(this.containerEl)
+            .setName("Handoff summary runtime")
+            .setDesc("Pinned independently from the interactive chat runtime.")
+            .addDropdown((dropdown) => {
+            dropdown
+                .addOption("acp", "ACP")
+                .addOption("codex-native", "Codex native")
+                .setValue(settings.handoffSummaryRuntime)
+                .onChange((value) => {
+                void this.aiPlugin.updateSettings({
+                    handoffSummaryRuntime: value === "codex-native" ? "codex-native" : "acp",
+                });
+            });
+        });
+        new Setting(this.containerEl)
+            .setName("Handoff summary agent")
+            .setDesc("Pinned independently from the interactive chat agent.")
+            .addDropdown((dropdown) => {
+            for (const id of ACP_AGENT_IDS) {
+                dropdown.addOption(id, ACP_AGENT_LABELS[id]);
+            }
+            dropdown.setValue(settings.handoffSummaryAgent).onChange((value) => {
+                void this.aiPlugin.updateSettings({
+                    handoffSummaryAgent: value,
+                });
+            });
+        });
+        new Setting(this.containerEl)
+            .setName("Handoff summary model")
+            .setDesc("Exact model used only for restricted background summaries.")
+            .addText((text) => {
+            text.setValue(settings.handoffSummaryModel).onChange((value) => {
+                void this.aiPlugin.updateSettings({
+                    handoffSummaryModel: value,
+                });
+            });
+        });
+        new Setting(this.containerEl)
+            .setName("Application tools")
+            .setDesc("Expose enabled application tools to new agent bindings. Existing bindings keep their frozen tool list.")
+            .addToggle((toggle) => {
+            toggle.setValue(settings.appToolsEnabled).onChange((value) => {
+                void this.aiPlugin.updateSettings({ appToolsEnabled: value });
+            });
+        });
+        for (const row of listAppToolSettingRows(this.app, settings)) {
+            new Setting(this.containerEl)
+                .setName(row.name)
+                .setDesc(row.description)
+                .addToggle((toggle) => {
+                toggle.setValue(row.enabled).onChange((value) => {
+                    const registered = this.app.agentTools.get(row.name);
+                    if (!registered)
+                        return;
+                    void this.aiPlugin.updateSettings(applyAppToolEnablement(this.aiPlugin.getSettings(), { name: registered.tool.name, owner: registered.owner }, value, registeredAppToolRefs(this.app)));
+                });
+            });
+        }
+    }
+    async loadModels(dropdown, settings, setting) {
+        try {
+            const models = await this.aiPlugin.models.listModels(settings.acpAgent);
+            if (models.length === 0) {
+                setting.setDesc(`The ${settings.acpAgent} provider returned no model catalog; keeping the saved selection.`);
+                dropdown.setDisabled(false);
+                return;
+            }
+            const selected = models.some((model) => model.model === settings.defaultModel)
+                ? settings.defaultModel
+                : (models.find((model) => model.isDefault) ?? models[0]).model;
+            dropdown
+                .setItems(models.map((model) => ({
+                value: model.model,
+                label: model.badges?.length
+                    ? `${model.displayName ?? model.model} ${model.badges.join(" · ")}`
+                    : (model.displayName ?? model.model),
+            })))
+                .setValue(selected)
+                .setDisabled(false)
+                .onChange((value) => {
+                void this.aiPlugin.updateSettings({ defaultModel: String(value) });
+            });
+            if (selected !== settings.defaultModel) {
+                await this.aiPlugin.updateSettings({ defaultModel: selected });
+            }
+        }
+        catch (error) {
+            setting.setDesc(`Model catalog unavailable; keeping the saved selection. ${error instanceof Error ? error.message : String(error)}`);
+            dropdown.setDisabled(false).onChange((value) => {
+                void this.aiPlugin.updateSettings({ defaultModel: String(value) });
+            });
+        }
+    }
+}

package/dist/settings/ai-settings.d.ts

@@ -0,0 +1,43 @@
+import type { AiThinkingLevel } from "../core/types";
+import { type AcpAgentId } from "./acp-agents";
+export type AppToolEnablementOwner = {
+    pluginId: string;
+    source: "core" | "community" | "official" | "system";
+};
+export type AppToolEnablementRef = {
+    name: string;
+    owner: AppToolEnablementOwner;
+};
+export type AiPluginSettings = {
+    defaultRuntime: "auto" | "acp" | "codex-native" | "fake";
+    acpAgent: AcpAgentId;
+    defaultModels: Record<AcpAgentId, string>;
+    /** Active-agent compatibility alias. Persisted model ownership lives in defaultModels. */
+    defaultModel: string;
+    thinking: AiThinkingLevel;
+    memoryAutomaticRecall: boolean;
+    memoryConsolidationEnabled: boolean;
+    memoryConsolidationRuntime: "acp" | "codex-native";
+    memoryConsolidationAgent: AcpAgentId;
+    memoryConsolidationModel: string;
+    handoffSummariesEnabled: boolean;
+    handoffSummaryRuntime: "acp" | "codex-native";
+    handoffSummaryAgent: AcpAgentId;
+    handoffSummaryModel: string;
+    appToolsEnabled: boolean;
+    disabledAppToolNames: string[];
+    enabledAppToolNames: string[];
+    /** @deprecated Migrated into enabledAppToolNames; omitted from new writes when empty. */
+    enabledCommunityToolPluginIds: string[];
+};
+export type StoredAiSettings = Partial<AiPluginSettings> & {
+    enabledCommunityToolPluginIds?: string[];
+};
+export declare const DEFAULT_AI_SETTINGS: AiPluginSettings;
+export declare const APP_TOOL_SETTING_PREFIX = "ai.appTools.";
+export declare function isCommunityAppToolOwner(owner: AppToolEnablementOwner): boolean;
+export declare function appToolSettingId(toolName: string): string;
+export declare function isAppToolEnabled(tool: AppToolEnablementRef, settings: Pick<AiPluginSettings, "disabledAppToolNames" | "enabledAppToolNames" | "enabledCommunityToolPluginIds">): boolean;
+export declare function migrateLegacyCommunityToolOptIns(settings: AiPluginSettings, registeredTools: readonly AppToolEnablementRef[]): AiPluginSettings;
+export declare function applyAppToolEnablement(settings: AiPluginSettings, tool: AppToolEnablementRef, enabled: boolean, registeredTools: readonly AppToolEnablementRef[]): Pick<AiPluginSettings, "disabledAppToolNames" | "enabledAppToolNames" | "enabledCommunityToolPluginIds">;
+export declare function mergeAiSettings(value: StoredAiSettings | null | undefined, registeredTools?: readonly AppToolEnablementRef[]): AiPluginSettings;

package/dist/settings/ai-settings.js

@@ -0,0 +1,147 @@
+import { DEFAULT_ACP_AGENT, normalizeAcpAgent, } from "./acp-agents";
+export const DEFAULT_AI_SETTINGS = {
+    defaultRuntime: "auto",
+    acpAgent: DEFAULT_ACP_AGENT,
+    defaultModels: {
+        codex: "gpt-5.6-sol",
+        cursor: "",
+    },
+    defaultModel: "gpt-5.6-sol",
+    thinking: "medium",
+    memoryAutomaticRecall: false,
+    memoryConsolidationEnabled: false,
+    memoryConsolidationRuntime: "acp",
+    memoryConsolidationAgent: "codex",
+    memoryConsolidationModel: "gpt-5.6-sol",
+    handoffSummariesEnabled: false,
+    handoffSummaryRuntime: "acp",
+    handoffSummaryAgent: "codex",
+    handoffSummaryModel: "gpt-5.6-sol",
+    appToolsEnabled: true,
+    disabledAppToolNames: [],
+    enabledAppToolNames: [],
+    enabledCommunityToolPluginIds: [],
+};
+export const APP_TOOL_SETTING_PREFIX = "ai.appTools.";
+const THINKING_LEVELS = new Set([
+    "off",
+    "low",
+    "medium",
+    "high",
+]);
+const LEGACY_FILE_TOOL_NAMES = {
+    notes_read: "read",
+    notes_patch: "edit",
+};
+function migrateLegacyFileToolName(name) {
+    return LEGACY_FILE_TOOL_NAMES[name] ?? name;
+}
+function normalizeNameList(value) {
+    return [
+        ...new Set((value ?? [])
+            .map((item) => migrateLegacyFileToolName(item.trim()))
+            .filter(Boolean)),
+    ].sort();
+}
+export function isCommunityAppToolOwner(owner) {
+    return owner.source === "community";
+}
+export function appToolSettingId(toolName) {
+    return `${APP_TOOL_SETTING_PREFIX}${toolName}`;
+}
+export function isAppToolEnabled(tool, settings) {
+    if (isCommunityAppToolOwner(tool.owner)) {
+        return (settings.enabledAppToolNames.includes(tool.name) ||
+            settings.enabledCommunityToolPluginIds.includes(tool.owner.pluginId));
+    }
+    return !settings.disabledAppToolNames.includes(tool.name);
+}
+export function migrateLegacyCommunityToolOptIns(settings, registeredTools) {
+    const leftover = settings.enabledCommunityToolPluginIds;
+    if (leftover.length === 0)
+        return settings;
+    const opted = new Set(leftover);
+    const names = new Set(settings.enabledAppToolNames);
+    const seenOwners = new Set();
+    for (const tool of registeredTools) {
+        if (!isCommunityAppToolOwner(tool.owner) ||
+            !opted.has(tool.owner.pluginId)) {
+            continue;
+        }
+        names.add(tool.name);
+        seenOwners.add(tool.owner.pluginId);
+    }
+    if (seenOwners.size === 0)
+        return settings;
+    return {
+        ...settings,
+        enabledAppToolNames: [...names].sort(),
+        enabledCommunityToolPluginIds: leftover.filter((pluginId) => !seenOwners.has(pluginId)),
+    };
+}
+export function applyAppToolEnablement(settings, tool, enabled, registeredTools) {
+    const migrated = migrateLegacyCommunityToolOptIns(settings, registeredTools);
+    if (isCommunityAppToolOwner(tool.owner)) {
+        const names = new Set(migrated.enabledAppToolNames);
+        if (enabled)
+            names.add(tool.name);
+        else
+            names.delete(tool.name);
+        return {
+            disabledAppToolNames: migrated.disabledAppToolNames,
+            enabledAppToolNames: [...names].sort(),
+            enabledCommunityToolPluginIds: migrated.enabledCommunityToolPluginIds,
+        };
+    }
+    const disabled = new Set(migrated.disabledAppToolNames);
+    if (enabled)
+        disabled.delete(tool.name);
+    else
+        disabled.add(tool.name);
+    return {
+        disabledAppToolNames: [...disabled].sort(),
+        enabledAppToolNames: migrated.enabledAppToolNames,
+        enabledCommunityToolPluginIds: migrated.enabledCommunityToolPluginIds,
+    };
+}
+export function mergeAiSettings(value, registeredTools) {
+    const acpAgent = normalizeAcpAgent(value?.acpAgent);
+    const storedModels = value?.defaultModels;
+    const legacyModel = value?.defaultModel?.trim();
+    const defaultModels = {
+        codex: storedModels?.codex?.trim() ||
+            legacyModel ||
+            DEFAULT_AI_SETTINGS.defaultModels.codex,
+        cursor: storedModels?.cursor?.trim() || "",
+    };
+    const thinking = value?.thinking;
+    const merged = {
+        defaultRuntime: value?.defaultRuntime ?? DEFAULT_AI_SETTINGS.defaultRuntime,
+        acpAgent,
+        defaultModels,
+        defaultModel: defaultModels[acpAgent],
+        thinking: thinking && THINKING_LEVELS.has(thinking)
+            ? thinking
+            : DEFAULT_AI_SETTINGS.thinking,
+        memoryAutomaticRecall: value?.memoryAutomaticRecall === true,
+        memoryConsolidationEnabled: value?.memoryConsolidationEnabled === true,
+        memoryConsolidationRuntime: value?.memoryConsolidationRuntime === "codex-native"
+            ? "codex-native"
+            : "acp",
+        memoryConsolidationAgent: normalizeAcpAgent(value?.memoryConsolidationAgent),
+        memoryConsolidationModel: value?.memoryConsolidationModel?.trim() ||
+            DEFAULT_AI_SETTINGS.memoryConsolidationModel,
+        handoffSummariesEnabled: value?.handoffSummariesEnabled === true,
+        handoffSummaryRuntime: value?.handoffSummaryRuntime === "codex-native" ? "codex-native" : "acp",
+        handoffSummaryAgent: normalizeAcpAgent(value?.handoffSummaryAgent),
+        handoffSummaryModel: value?.handoffSummaryModel?.trim() ||
+            DEFAULT_AI_SETTINGS.handoffSummaryModel,
+        appToolsEnabled: value?.appToolsEnabled !== false,
+        disabledAppToolNames: normalizeNameList(value?.disabledAppToolNames),
+        enabledAppToolNames: normalizeNameList(value?.enabledAppToolNames),
+        enabledCommunityToolPluginIds: normalizeNameList(value?.enabledCommunityToolPluginIds),
+    };
+    return registeredTools
+        ? migrateLegacyCommunityToolOptIns(merged, registeredTools)
+        : merged;
+}

package/dist/settings/app-tool-setting-rows.d.ts

@@ -0,0 +1,16 @@
+import type { App } from "@lapis-notes/api";
+import type { AppToolEffect } from "@lapis-notes/api/agent-tools";
+import { type AiPluginSettings, type AppToolEnablementOwner, type AppToolEnablementRef } from "./ai-settings";
+export type AppToolSettingRow = {
+    name: string;
+    fieldId: string;
+    pluginId: string;
+    pluginLabel: string;
+    effect: AppToolEffect;
+    description: string;
+    owner: AppToolEnablementOwner;
+    enabled: boolean;
+};
+export declare function registeredAppToolRefs(app: App): AppToolEnablementRef[];
+export declare function contributingPluginLabel(app: App, pluginId: string): string;
+export declare function listAppToolSettingRows(app: App, settings: AiPluginSettings): AppToolSettingRow[];

package/dist/settings/app-tool-setting-rows.js

@@ -0,0 +1,30 @@
+import { appToolSettingId, isAppToolEnabled, } from "./ai-settings";
+export function registeredAppToolRefs(app) {
+    return app.agentTools.list().map((registered) => ({
+        name: registered.tool.name,
+        owner: registered.owner,
+    }));
+}
+export function contributingPluginLabel(app, pluginId) {
+    const name = app.plugins.plugins.get(pluginId)?.manifest.name?.trim();
+    return name || pluginId;
+}
+export function listAppToolSettingRows(app, settings) {
+    return app.agentTools
+        .list()
+        .slice()
+        .sort((left, right) => left.tool.name.localeCompare(right.tool.name))
+        .map((registered) => {
+        const pluginLabel = contributingPluginLabel(app, registered.owner.pluginId);
+        return {
+            name: registered.tool.name,
+            fieldId: appToolSettingId(registered.tool.name),
+            pluginId: registered.owner.pluginId,
+            pluginLabel,
+            effect: registered.tool.effect,
+            description: `${pluginLabel} · ${registered.tool.effect}`,
+            owner: registered.owner,
+            enabled: isAppToolEnabled({ name: registered.tool.name, owner: registered.owner }, settings),
+        };
+    });
+}

package/dist/settings/register-ai-settings.d.ts

@@ -0,0 +1,3 @@
+import type { Plugin } from "@lapis-notes/api";
+import type { AiPlugin } from "../ai-plugin";
+export declare function registerAiSettings(plugin: AiPlugin & Plugin): void;