@lapis-notes/ai 0.1.0

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

@@ -0,0 +1,393 @@
+import { getWorkspaceHostBinding } from "@lapis-notes/api/workspace-host";
+import { ACP_AGENT_IDS, normalizeAcpAgent, } from "./acp-agents";
+import { APP_TOOL_SETTING_PREFIX, DEFAULT_AI_SETTINGS, applyAppToolEnablement, migrateLegacyCommunityToolOptIns, } from "./ai-settings";
+import { listAppToolSettingRows, registeredAppToolRefs, } from "./app-tool-setting-rows";
+const FIELD_IDS = {
+    defaultRuntime: "ai.defaultRuntime",
+    acpAgent: "ai.acpAgent",
+    defaultModel: "ai.defaultModel",
+    thinking: "ai.thinking",
+    memoryAutomaticRecall: "ai.memoryAutomaticRecall",
+    memoryConsolidationEnabled: "ai.memoryConsolidationEnabled",
+    memoryConsolidationRuntime: "ai.memoryConsolidationRuntime",
+    memoryConsolidationAgent: "ai.memoryConsolidationAgent",
+    memoryConsolidationModel: "ai.memoryConsolidationModel",
+    handoffSummariesEnabled: "ai.handoffSummariesEnabled",
+    handoffSummaryRuntime: "ai.handoffSummaryRuntime",
+    handoffSummaryAgent: "ai.handoffSummaryAgent",
+    handoffSummaryModel: "ai.handoffSummaryModel",
+    appToolsEnabled: "ai.appToolsEnabled",
+    appTools: "ai.appTools",
+};
+export function registerAiSettings(plugin) {
+    const binding = getWorkspaceHostBinding(plugin.app.workspace);
+    if (!binding)
+        return;
+    const controller = binding.controller;
+    const settings = plugin.getSettings();
+    const modelSourceId = (provider) => `ai.models.${provider}`;
+    const persistLegacyToolMigration = () => {
+        const current = plugin.getSettings();
+        const migrated = migrateLegacyCommunityToolOptIns(current, registeredAppToolRefs(plugin.app));
+        if (migrated.enabledAppToolNames.join("\0") ===
+            current.enabledAppToolNames.join("\0") &&
+            migrated.enabledCommunityToolPluginIds.join("\0") ===
+                current.enabledCommunityToolPluginIds.join("\0")) {
+            return;
+        }
+        void plugin.updateSettings({
+            enabledAppToolNames: migrated.enabledAppToolNames,
+            enabledCommunityToolPluginIds: migrated.enabledCommunityToolPluginIds,
+        });
+    };
+    for (const provider of ACP_AGENT_IDS) {
+        const dispose = controller.configuration.optionSources.register({
+            id: modelSourceId(provider),
+            load: async () => {
+                const current = plugin.getSettings();
+                const saved = current.defaultModels[provider];
+                try {
+                    const models = await plugin.models.listModels(provider);
+                    if (models.length === 0) {
+                        return saved
+                            ? [
+                                {
+                                    value: saved,
+                                    label: saved,
+                                    description: "Saved model; the provider returned no catalog.",
+                                },
+                            ]
+                            : [];
+                    }
+                    const selected = models.some((model) => model.model === saved)
+                        ? saved
+                        : (models.find((model) => model.isDefault) ?? models[0])?.model;
+                    if (selected && selected !== saved) {
+                        await plugin.updateSettings({
+                            defaultModels: { ...current.defaultModels, [provider]: selected },
+                        });
+                        if (plugin.getSettings().acpAgent === provider) {
+                            controller.settings.update(FIELD_IDS.defaultModel, selected);
+                        }
+                    }
+                    return models.map((model) => ({
+                        value: model.model,
+                        label: model.displayName ?? model.model,
+                        description: model.badges?.length
+                            ? model.badges.join(" · ")
+                            : model.description,
+                    }));
+                }
+                catch (error) {
+                    return saved
+                        ? [
+                            {
+                                value: saved,
+                                label: saved,
+                                description: `Saved model; catalog unavailable: ${error instanceof Error ? error.message : String(error)}`,
+                            },
+                        ]
+                        : [];
+                }
+            },
+        });
+        plugin.register(dispose);
+    }
+    const createSection = (current) => ({
+        id: "ai",
+        title: "AI",
+        description: "Agent runtime, model, and thinking defaults.",
+        icon: "sparkles",
+        order: 35,
+        navigationGroupId: "core-plugins",
+        sourcePluginId: plugin.id,
+        fields: [
+            {
+                id: FIELD_IDS.defaultRuntime,
+                type: "enum",
+                title: "Default runtime",
+                description: "Capability-based selection stays automatic unless you pin a runtime.",
+                default: DEFAULT_AI_SETTINGS.defaultRuntime,
+                options: [
+                    { value: "auto", label: "Automatic" },
+                    { value: "acp", label: "ACP" },
+                    { value: "codex-native", label: "Codex native" },
+                    { value: "fake", label: "Fake (tests)" },
+                ],
+            },
+            {
+                id: FIELD_IDS.acpAgent,
+                type: "enum",
+                title: "ACP agent",
+                description: "Built-in ACP agent used when ACP is selected.",
+                default: DEFAULT_AI_SETTINGS.acpAgent,
+                options: ACP_AGENT_IDS.map((value) => ({
+                    value,
+                    label: value === "cursor" ? "Cursor" : "Codex",
+                })),
+            },
+            {
+                id: FIELD_IDS.defaultModel,
+                type: "string",
+                title: "Default model",
+                description: "Model reported by the selected agent provider and sent on the next request.",
+                default: current.defaultModel,
+                optionsSource: modelSourceId(current.acpAgent),
+                allowUnknownOptions: false,
+            },
+            {
+                id: FIELD_IDS.thinking,
+                type: "enum",
+                title: "Thinking",
+                description: "How much model reasoning to request on each turn.",
+                default: DEFAULT_AI_SETTINGS.thinking,
+                options: [
+                    { value: "off", label: "Off" },
+                    { value: "low", label: "Low" },
+                    { value: "medium", label: "Medium" },
+                    { value: "high", label: "High" },
+                ],
+            },
+            {
+                id: FIELD_IDS.memoryAutomaticRecall,
+                type: "boolean",
+                title: "Automatic memory recall",
+                description: "Inject up to three trusted curated memories into a turn. Transcript evidence remains available only through memory tools.",
+                default: DEFAULT_AI_SETTINGS.memoryAutomaticRecall,
+            },
+            {
+                id: FIELD_IDS.memoryConsolidationEnabled,
+                type: "boolean",
+                title: "Automatic memory consolidation",
+                description: "Use the separately pinned processor below for bounded background proposals. This may consume provider quota.",
+                default: DEFAULT_AI_SETTINGS.memoryConsolidationEnabled,
+            },
+            {
+                id: FIELD_IDS.memoryConsolidationRuntime,
+                type: "enum",
+                title: "Memory processor runtime",
+                description: "Pinned independently from the interactive chat runtime.",
+                default: DEFAULT_AI_SETTINGS.memoryConsolidationRuntime,
+                options: [
+                    { value: "acp", label: "ACP" },
+                    { value: "codex-native", label: "Codex native" },
+                ],
+            },
+            {
+                id: FIELD_IDS.memoryConsolidationAgent,
+                type: "enum",
+                title: "Memory processor agent",
+                description: "Pinned independently from the interactive chat agent.",
+                default: DEFAULT_AI_SETTINGS.memoryConsolidationAgent,
+                options: ACP_AGENT_IDS.map((value) => ({
+                    value,
+                    label: value === "cursor" ? "Cursor" : "Codex",
+                })),
+            },
+            {
+                id: FIELD_IDS.memoryConsolidationModel,
+                type: "string",
+                title: "Memory processor model",
+                description: "Exact model used only for restricted background consolidation.",
+                default: DEFAULT_AI_SETTINGS.memoryConsolidationModel,
+            },
+            {
+                id: FIELD_IDS.handoffSummariesEnabled,
+                type: "boolean",
+                title: "Background handoff summaries",
+                description: "Prepare verified summaries after long turns for future cross-agent switches. This never runs during a switch and may consume provider quota.",
+                default: DEFAULT_AI_SETTINGS.handoffSummariesEnabled,
+            },
+            {
+                id: FIELD_IDS.handoffSummaryRuntime,
+                type: "enum",
+                title: "Handoff summary runtime",
+                description: "Pinned independently from the interactive chat runtime.",
+                default: DEFAULT_AI_SETTINGS.handoffSummaryRuntime,
+                options: [
+                    { value: "acp", label: "ACP" },
+                    { value: "codex-native", label: "Codex native" },
+                ],
+            },
+            {
+                id: FIELD_IDS.handoffSummaryAgent,
+                type: "enum",
+                title: "Handoff summary agent",
+                description: "Pinned independently from the interactive chat agent.",
+                default: DEFAULT_AI_SETTINGS.handoffSummaryAgent,
+                options: ACP_AGENT_IDS.map((value) => ({
+                    value,
+                    label: value === "cursor" ? "Cursor" : "Codex",
+                })),
+            },
+            {
+                id: FIELD_IDS.handoffSummaryModel,
+                type: "string",
+                title: "Handoff summary model",
+                description: "Exact model used only for restricted background summaries.",
+                default: DEFAULT_AI_SETTINGS.handoffSummaryModel,
+            },
+            {
+                id: FIELD_IDS.appToolsEnabled,
+                type: "boolean",
+                title: "Application tools",
+                description: "Expose enabled application tools to newly created agent bindings.",
+                default: DEFAULT_AI_SETTINGS.appToolsEnabled,
+            },
+            {
+                id: FIELD_IDS.appTools,
+                type: "group",
+                presentation: "toggle-table",
+                title: "Registered tools",
+                description: "Enable or disable each currently registered tool for new agent bindings.",
+                fields: listAppToolSettingRows(plugin.app, current).map((row) => ({
+                    id: row.fieldId,
+                    type: "boolean",
+                    title: row.name,
+                    description: row.description,
+                    default: row.owner.source !== "community",
+                })),
+            },
+        ],
+    });
+    let disposeSection = controller.registerSettingsSection(createSection(settings));
+    plugin.register(() => disposeSection());
+    controller.settings.update(FIELD_IDS.defaultRuntime, settings.defaultRuntime);
+    controller.settings.update(FIELD_IDS.acpAgent, settings.acpAgent);
+    controller.settings.update(FIELD_IDS.defaultModel, settings.defaultModel);
+    controller.settings.update(FIELD_IDS.thinking, settings.thinking);
+    controller.settings.update(FIELD_IDS.memoryAutomaticRecall, settings.memoryAutomaticRecall);
+    controller.settings.update(FIELD_IDS.memoryConsolidationEnabled, settings.memoryConsolidationEnabled);
+    controller.settings.update(FIELD_IDS.memoryConsolidationRuntime, settings.memoryConsolidationRuntime);
+    controller.settings.update(FIELD_IDS.memoryConsolidationAgent, settings.memoryConsolidationAgent);
+    controller.settings.update(FIELD_IDS.memoryConsolidationModel, settings.memoryConsolidationModel);
+    controller.settings.update(FIELD_IDS.handoffSummariesEnabled, settings.handoffSummariesEnabled);
+    controller.settings.update(FIELD_IDS.handoffSummaryRuntime, settings.handoffSummaryRuntime);
+    controller.settings.update(FIELD_IDS.handoffSummaryAgent, settings.handoffSummaryAgent);
+    controller.settings.update(FIELD_IDS.handoffSummaryModel, settings.handoffSummaryModel);
+    controller.settings.update(FIELD_IDS.appToolsEnabled, settings.appToolsEnabled);
+    const syncAppToolValues = (current) => {
+        for (const row of listAppToolSettingRows(plugin.app, current)) {
+            controller.settings.update(row.fieldId, row.enabled);
+        }
+    };
+    syncAppToolValues(settings);
+    persistLegacyToolMigration();
+    const refreshSection = (current) => {
+        disposeSection();
+        disposeSection = controller.registerSettingsSection(createSection(current));
+        syncAppToolValues(current);
+    };
+    const toolRegistryRef = plugin.app.agentTools.on("changed", () => {
+        persistLegacyToolMigration();
+        refreshSection(plugin.getSettings());
+    });
+    plugin.register(() => plugin.app.agentTools.offref(toolRegistryRef));
+    const changeRef = controller.settings.on("change", (event) => {
+        if (!event.id || !event.id.startsWith("ai."))
+            return;
+        const values = controller.settings.getSnapshot().values;
+        if (event.id === FIELD_IDS.acpAgent) {
+            void (async () => {
+                await plugin.updateSettings({
+                    acpAgent: normalizeAcpAgent(values[FIELD_IDS.acpAgent]),
+                });
+                const next = plugin.getSettings();
+                refreshSection(next);
+                controller.settings.update(FIELD_IDS.defaultModel, next.defaultModel);
+            })();
+            return;
+        }
+        if (event.id === FIELD_IDS.defaultModel) {
+            void plugin.updateSettings({
+                defaultModel: String(values[FIELD_IDS.defaultModel] ?? ""),
+            });
+            return;
+        }
+        if (event.id === FIELD_IDS.defaultRuntime) {
+            void plugin.updateSettings({
+                defaultRuntime: values[FIELD_IDS.defaultRuntime],
+            });
+            return;
+        }
+        if (event.id === FIELD_IDS.thinking) {
+            void plugin.updateSettings({
+                thinking: values[FIELD_IDS.thinking],
+            });
+            return;
+        }
+        if (event.id === FIELD_IDS.memoryAutomaticRecall) {
+            void plugin.updateSettings({
+                memoryAutomaticRecall: values[FIELD_IDS.memoryAutomaticRecall] === true,
+            });
+            return;
+        }
+        if (event.id === FIELD_IDS.memoryConsolidationEnabled) {
+            void plugin.updateSettings({
+                memoryConsolidationEnabled: values[FIELD_IDS.memoryConsolidationEnabled] === true,
+            });
+            return;
+        }
+        if (event.id === FIELD_IDS.memoryConsolidationRuntime) {
+            void plugin.updateSettings({
+                memoryConsolidationRuntime: values[FIELD_IDS.memoryConsolidationRuntime] === "codex-native"
+                    ? "codex-native"
+                    : "acp",
+            });
+            return;
+        }
+        if (event.id === FIELD_IDS.memoryConsolidationAgent) {
+            void plugin.updateSettings({
+                memoryConsolidationAgent: normalizeAcpAgent(values[FIELD_IDS.memoryConsolidationAgent]),
+            });
+            return;
+        }
+        if (event.id === FIELD_IDS.memoryConsolidationModel) {
+            void plugin.updateSettings({
+                memoryConsolidationModel: String(values[FIELD_IDS.memoryConsolidationModel] ?? ""),
+            });
+            return;
+        }
+        if (event.id === FIELD_IDS.handoffSummariesEnabled) {
+            void plugin.updateSettings({
+                handoffSummariesEnabled: values[FIELD_IDS.handoffSummariesEnabled] === true,
+            });
+            return;
+        }
+        if (event.id === FIELD_IDS.handoffSummaryRuntime) {
+            void plugin.updateSettings({
+                handoffSummaryRuntime: values[FIELD_IDS.handoffSummaryRuntime] === "codex-native"
+                    ? "codex-native"
+                    : "acp",
+            });
+            return;
+        }
+        if (event.id === FIELD_IDS.handoffSummaryAgent) {
+            void plugin.updateSettings({
+                handoffSummaryAgent: normalizeAcpAgent(values[FIELD_IDS.handoffSummaryAgent]),
+            });
+            return;
+        }
+        if (event.id === FIELD_IDS.handoffSummaryModel) {
+            void plugin.updateSettings({
+                handoffSummaryModel: String(values[FIELD_IDS.handoffSummaryModel] ?? ""),
+            });
+            return;
+        }
+        if (event.id === FIELD_IDS.appToolsEnabled) {
+            void plugin.updateSettings({
+                appToolsEnabled: values[FIELD_IDS.appToolsEnabled] !== false,
+            });
+            return;
+        }
+        if (event.id.startsWith(APP_TOOL_SETTING_PREFIX) &&
+            event.id !== FIELD_IDS.appTools) {
+            const toolName = event.id.slice(APP_TOOL_SETTING_PREFIX.length);
+            const registered = plugin.app.agentTools.get(toolName);
+            if (!registered)
+                return;
+            void plugin.updateSettings(applyAppToolEnablement(plugin.getSettings(), { name: registered.tool.name, owner: registered.owner }, values[event.id] === true, registeredAppToolRefs(plugin.app)));
+        }
+    });
+    plugin.register(() => controller.settings.offref(changeRef));
+}

package/dist/skills/activation.d.ts

@@ -0,0 +1,2 @@
+import type { SkillActivation } from "./types";
+export declare function projectSkillActivationPrompt(text: string, activations?: readonly SkillActivation[]): string;

package/dist/skills/activation.js

@@ -0,0 +1,20 @@
+import { hasHostFilesystemPath } from "./manifest";
+export function projectSkillActivationPrompt(text, activations) {
+    const activation = activations?.[0];
+    if (!activation?.instructions.trim())
+        return text;
+    if (hasHostFilesystemPath(activation.instructions))
+        return text;
+    const name = escapeAttribute(activation.skillName);
+    const version = escapeAttribute(activation.version);
+    return [
+        `<skill_activation name="${name}" version="${version}">`,
+        activation.instructions.trim(),
+        "</skill_activation>",
+        "",
+        text,
+    ].join("\n");
+}
+function escapeAttribute(value) {
+    return value.replaceAll("&", "&amp;").replaceAll('"', "&quot;");
+}

package/dist/skills/bundled/lapis-notes.d.ts

@@ -0,0 +1,3 @@
+import type { LoadedAppSkill } from "../types";
+export declare const LAPIS_NOTES_SKILL_MARKDOWN = "---\nname: lapis-notes\ndescription: Guidance for working with notes, folders, search, links, and other Lapis Notes capabilities.\nuser-invocable: false\n---\n\n# Lapis Notes\n\nYou are operating inside Lapis Notes.\n\nPrefer application tools over manually inspecting the notes filesystem.\n\n## Finding information\n\nUse notes_search when the user asks to find, recall, locate, compare, or research information from their notes.\n\nSearch first, then use read on promising results.\n\nDo not guess note paths when search can locate the note.\n\n## Navigating notes\n\nUse notes_list to inspect folder contents when structure matters.\n\nUse related link tools when relationships between notes are relevant and those tools are available.\n\n## Scope\n\nTool access is automatically scoped by Lapis.\n\nDo not attempt to widen that scope using filesystem paths or shell tools.\n\nThe current conversation's scope and launch note are supplied by the host.\n\n## Writing\n\nUse Lapis note mutation tools when they are available instead of editing application-owned note files through generic filesystem tools.\n\nWrites may require user approval.\n\n## Tool availability\n\nThe exact tool set can vary by installed extensions and conversation scope.\n\nUse the tools exposed for the current session rather than assuming a particular extension is installed.\n";
+export declare const BUNDLED_LAPIS_NOTES_SKILL: LoadedAppSkill;

package/dist/skills/bundled/lapis-notes.js

@@ -0,0 +1,52 @@
+import { parseSkillMarkdown } from "../parser";
+export const LAPIS_NOTES_SKILL_MARKDOWN = `---
+name: lapis-notes
+description: Guidance for working with notes, folders, search, links, and other Lapis Notes capabilities.
+user-invocable: false
+---
+
+# Lapis Notes
+
+You are operating inside Lapis Notes.
+
+Prefer application tools over manually inspecting the notes filesystem.
+
+## Finding information
+
+Use notes_search when the user asks to find, recall, locate, compare, or research information from their notes.
+
+Search first, then use read on promising results.
+
+Do not guess note paths when search can locate the note.
+
+## Navigating notes
+
+Use notes_list to inspect folder contents when structure matters.
+
+Use related link tools when relationships between notes are relevant and those tools are available.
+
+## Scope
+
+Tool access is automatically scoped by Lapis.
+
+Do not attempt to widen that scope using filesystem paths or shell tools.
+
+The current conversation's scope and launch note are supplied by the host.
+
+## Writing
+
+Use Lapis note mutation tools when they are available instead of editing application-owned note files through generic filesystem tools.
+
+Writes may require user approval.
+
+## Tool availability
+
+The exact tool set can vary by installed extensions and conversation scope.
+
+Use the tools exposed for the current session rather than assuming a particular extension is installed.
+`;
+export const BUNDLED_LAPIS_NOTES_SKILL = parseSkillMarkdown(LAPIS_NOTES_SKILL_MARKDOWN, {
+    path: "bundled/lapis-notes/SKILL.md",
+    source: "bundled",
+    root: "bundled/lapis-notes",
+});

package/dist/skills/bundled/research.d.ts

@@ -0,0 +1,6 @@
+import type { LoadedAppSkill } from "../types";
+export declare const RESEARCH_SKILL_MARKDOWN = "---\nname: research\ndescription: Research notes in the current folder and synthesize an answer.\nuser-invocable: true\nargument-hint: \"<topic>\"\n---\nResearch the given topic in the current conversation folder.\n\n1. Use notes_search to find relevant notes.\n2. Use read to inspect the best matches.\n3. Follow further searches when needed.\n4. Synthesize a concise answer and cite note paths.\n";
+export declare const BUNDLED_RESEARCH_SKILL: LoadedAppSkill;
+export declare const BUNDLED_APP_SKILLS: readonly LoadedAppSkill[];
+export declare const BUNDLED_SKILL_MARKDOWN: Readonly<Record<string, string>>;
+export declare const BUNDLED_SKILL_NAMES: Set<string>;

package/dist/skills/bundled/research.js

@@ -0,0 +1,29 @@
+import { parseSkillMarkdown } from "../parser";
+import { BUNDLED_LAPIS_NOTES_SKILL, LAPIS_NOTES_SKILL_MARKDOWN, } from "./lapis-notes";
+export const RESEARCH_SKILL_MARKDOWN = `---
+name: research
+description: Research notes in the current folder and synthesize an answer.
+user-invocable: true
+argument-hint: "<topic>"
+---
+Research the given topic in the current conversation folder.
+
+1. Use notes_search to find relevant notes.
+2. Use read to inspect the best matches.
+3. Follow further searches when needed.
+4. Synthesize a concise answer and cite note paths.
+`;
+export const BUNDLED_RESEARCH_SKILL = parseSkillMarkdown(RESEARCH_SKILL_MARKDOWN, {
+    path: "bundled/research/SKILL.md",
+    source: "bundled",
+    root: "bundled/research",
+});
+export const BUNDLED_APP_SKILLS = [
+    BUNDLED_LAPIS_NOTES_SKILL,
+    BUNDLED_RESEARCH_SKILL,
+];
+export const BUNDLED_SKILL_MARKDOWN = {
+    research: RESEARCH_SKILL_MARKDOWN,
+    "lapis-notes": LAPIS_NOTES_SKILL_MARKDOWN,
+};
+export const BUNDLED_SKILL_NAMES = new Set(Object.keys(BUNDLED_SKILL_MARKDOWN));

package/dist/skills/discovery.d.ts

@@ -0,0 +1,21 @@
+import type { Vault } from "@lapis-notes/api";
+import type { AppSkillRegistry } from "@lapis-notes/api/agent-skills";
+import type { LoadedAppSkill, SkillDiagnostic, SkillDiscoveryContext } from "./types";
+export interface DiscoveredSkills {
+    skills: LoadedAppSkill[];
+    diagnostics: SkillDiagnostic[];
+}
+export interface SkillDiscoveryOptions {
+    vault: Vault;
+    appSkills?: AppSkillRegistry;
+    bundled?: LoadedAppSkill[];
+    extensionFiles?: ReadonlyMap<string, Readonly<Record<string, string>>>;
+    extensionRootFor?: (ownerPluginId: string) => string | undefined;
+    userPrefix?: string;
+}
+export declare class SkillDiscovery {
+    #private;
+    private readonly options;
+    constructor(options: SkillDiscoveryOptions);
+    discover(context: SkillDiscoveryContext): Promise<DiscoveredSkills>;
+}