@lapis-notes/ai 0.1.0

package/dist/runtimes/fake/fake-runtime.js

@@ -0,0 +1,257 @@
+import { AsyncEventQueue } from "../../core/event-queue";
+import { DEFAULT_APPROVAL_OPTIONS, } from "../../core/types";
+export const FAKE_RICH_THINKING = "I will read the mentioned note, then summarize it.";
+export const FAKE_RICH_TOOL = {
+    id: "tool-vault-read",
+    name: "vault.read",
+    input: { path: "Notes/alpha.md" },
+    output: "heading: Notes",
+};
+export const FAKE_RICH_ASSISTANT_TEXT = [
+    "## Summary",
+    "",
+    "I read **Notes/alpha.md** and found a `TODO`.",
+    "",
+    "- One heading",
+    "- A note",
+].join("\n");
+export class FakeAgentSession {
+    id;
+    prompts = [];
+    contextBlocks = [];
+    configurations = [];
+    cancelled = false;
+    closed = false;
+    detached = false;
+    #events = new AsyncEventQueue();
+    #pending = new Map();
+    #pendingQuestions = new Map();
+    #requireApproval;
+    #requireQuestion;
+    #trace;
+    #nativeCommands;
+    constructor(id, requireApproval, trace = "echo", requireQuestion = false, nativeCommands = []) {
+        this.id = id;
+        this.#requireApproval = requireApproval;
+        this.#requireQuestion = requireQuestion;
+        this.#trace = trace;
+        this.#nativeCommands = nativeCommands;
+        if (nativeCommands.length > 0) {
+            this.#events.push({
+                type: "commands.update",
+                commands: nativeCommands,
+            });
+        }
+    }
+    events() {
+        return this.#events;
+    }
+    async send(input, options) {
+        if (this.closed)
+            throw new Error("Fake session is closed.");
+        this.prompts.push(input);
+        this.contextBlocks.push(structuredClone(options?.contextBlocks));
+        if (this.#trace === "rich") {
+            this.#events.push({
+                type: "thinking",
+                text: FAKE_RICH_THINKING,
+                kind: "reasoning",
+            });
+            this.#events.push({
+                type: "tool.start",
+                id: FAKE_RICH_TOOL.id,
+                name: FAKE_RICH_TOOL.name,
+                input: FAKE_RICH_TOOL.input,
+            });
+            this.#events.push({
+                type: "tool.end",
+                id: FAKE_RICH_TOOL.id,
+                name: FAKE_RICH_TOOL.name,
+                output: FAKE_RICH_TOOL.output,
+            });
+            this.#events.push({ type: "text", text: FAKE_RICH_ASSISTANT_TEXT });
+            this.#events.push({ type: "status", status: "session updated" });
+            this.#events.push({
+                type: "status",
+                status: "available commands updated (75)",
+            });
+            this.#events.push({
+                type: "usage",
+                usage: { used: 12_920, limit: 128_000 },
+            });
+        }
+        else {
+            this.#events.push({ type: "text", text: input });
+        }
+        if (this.#requireApproval) {
+            const request = createFakeApprovalRequest(`approval-${this.prompts.length}`);
+            this.#events.push({ type: "permission.request", request });
+            const optionId = await new Promise((resolve, reject) => {
+                this.#pending.set(request.id, { resolve, reject });
+            });
+            this.#events.push({
+                type: "status",
+                status: `approval:${request.id}:${optionId}`,
+            });
+        }
+        if (this.#requireQuestion) {
+            const request = createFakeQuestionRequest(`question-${this.prompts.length}`);
+            this.#events.push({ type: "question.request", request });
+            await new Promise((resolve, reject) => {
+                this.#pendingQuestions.set(request.id, { resolve, reject });
+            });
+        }
+        this.#events.push({ type: "completed", result: { prompt: input } });
+    }
+    async configure(input) {
+        this.configurations.push(structuredClone(input));
+        return {
+            ...(input.model ? { model: { status: "applied" } } : {}),
+            ...(input.thinking ? { thinking: { status: "applied" } } : {}),
+        };
+    }
+    async respondToApproval(requestId, optionId) {
+        const pending = this.#pending.get(requestId);
+        if (!pending) {
+            throw new Error(`Unknown approval request: ${requestId}`);
+        }
+        this.#pending.delete(requestId);
+        pending.resolve(optionId);
+    }
+    async respondToQuestion(requestId, answers) {
+        const pending = this.#pendingQuestions.get(requestId);
+        if (!pending) {
+            throw new Error(`Unknown question request: ${requestId}`);
+        }
+        this.#pendingQuestions.delete(requestId);
+        pending.resolve(answers);
+    }
+    async cancel() {
+        this.cancelled = true;
+        for (const [id, pending] of this.#pending) {
+            this.#pending.delete(id);
+            pending.reject(new Error("Session cancelled."));
+        }
+        for (const [id, pending] of this.#pendingQuestions) {
+            this.#pendingQuestions.delete(id);
+            pending.reject(new Error("Session cancelled."));
+        }
+        this.#events.push({ type: "status", status: "cancelled" });
+    }
+    async close() {
+        this.closed = true;
+        for (const [id, pending] of this.#pending) {
+            this.#pending.delete(id);
+            pending.reject(new Error("Session closed."));
+        }
+        for (const [id, pending] of this.#pendingQuestions) {
+            this.#pendingQuestions.delete(id);
+            pending.reject(new Error("Session closed."));
+        }
+        this.#events.close();
+    }
+    async detach() {
+        this.detached = true;
+        await this.close();
+    }
+}
+export class FakeAgentRuntime {
+    id;
+    sessions = [];
+    lastRequest = null;
+    #requireApproval;
+    #requireQuestion;
+    #resumeSupported;
+    #trace;
+    #nativeCommands;
+    constructor(options = {}) {
+        this.id = options.id ?? "fake";
+        this.#requireApproval = options.requireApproval ?? false;
+        this.#requireQuestion = options.requireQuestion ?? false;
+        this.#resumeSupported = options.resumeSupported ?? true;
+        this.#trace = options.trace ?? "echo";
+        this.#nativeCommands = options.nativeCommands ?? [];
+    }
+    capabilities() {
+        return {
+            sessions: true,
+            resume: this.#resumeSupported,
+            cancel: true,
+            steer: false,
+            modelSelection: true,
+            nativeTools: false,
+            mcpTools: true,
+            approvals: {
+                supported: true,
+                interactive: true,
+                persistentDecisions: true,
+                granularPermissions: false,
+                policyAmendments: false,
+            },
+        };
+    }
+    async supports(request) {
+        if (request.requirePolicyAmendments)
+            return false;
+        return true;
+    }
+    async start(request) {
+        this.lastRequest = request;
+        const session = new FakeAgentSession(`fake-${this.sessions.length + 1}`, this.#requireApproval || Boolean(request.requireApprovals), this.#trace, this.#requireQuestion, this.#nativeCommands);
+        this.sessions.push(session);
+        return session;
+    }
+    async resume(sessionId) {
+        if (!this.#resumeSupported) {
+            throw new Error("Fake runtime does not support resume.");
+        }
+        const existing = this.sessions.find((session) => session.id === sessionId);
+        if (!existing)
+            throw new Error(`Unknown fake session: ${sessionId}`);
+        if (!existing.closed)
+            return existing;
+        if (!existing.detached) {
+            throw new Error(`Unknown fake session: ${sessionId}`);
+        }
+        const resumed = new FakeAgentSession(sessionId, this.#requireApproval, this.#trace, this.#requireQuestion, this.#nativeCommands);
+        this.sessions.push(resumed);
+        return resumed;
+    }
+}
+function createFakeApprovalRequest(id) {
+    return {
+        id,
+        origin: "runtime",
+        kind: "execute",
+        title: "Allow the fake agent to continue?",
+        tool: { name: "fake.echo", input: { id } },
+        options: DEFAULT_APPROVAL_OPTIONS,
+    };
+}
+function createFakeQuestionRequest(id) {
+    return {
+        id,
+        title: "Agent needs input",
+        questions: [
+            {
+                id: "approach",
+                header: "Approach",
+                prompt: "How should I update the sample file?",
+                options: [
+                    {
+                        id: "approach-minimal",
+                        label: "Make the smallest change",
+                        description: "Keep the existing structure and edit only what is needed.",
+                    },
+                    {
+                        id: "approach-refactor",
+                        label: "Refactor while editing",
+                        description: "Clean up the surrounding structure as part of the change.",
+                    },
+                ],
+                allowOther: true,
+                secret: false,
+            },
+        ],
+    };
+}

package/dist/sessions/plugin-data.d.ts

@@ -0,0 +1,8 @@
+import { type AiPluginSettings } from "../settings/ai-settings";
+export type AiPluginData = {
+    settings: AiPluginSettings;
+    source: Record<string, unknown>;
+};
+export declare function parseAiPluginData(value: unknown): AiPluginData;
+export declare function serializeAiPluginData(data: AiPluginData): Record<string, unknown>;
+export declare function equalAiPluginData(left: AiPluginData, right: AiPluginData): boolean;

package/dist/sessions/plugin-data.js

@@ -0,0 +1,29 @@
+import { mergeAiSettings, } from "../settings/ai-settings";
+export function parseAiPluginData(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        return { settings: mergeAiSettings(null), source: {} };
+    }
+    const record = value;
+    const settingsSource = record.settings && typeof record.settings === "object"
+        ? record.settings
+        : record;
+    return {
+        settings: mergeAiSettings(settingsSource),
+        source: structuredClone(record),
+    };
+}
+export function serializeAiPluginData(data) {
+    const settings = structuredClone(data.settings);
+    if (settings.enabledCommunityToolPluginIds.length === 0) {
+        delete settings
+            .enabledCommunityToolPluginIds;
+    }
+    return {
+        ...structuredClone(data.source),
+        settings,
+    };
+}
+export function equalAiPluginData(left, right) {
+    return (JSON.stringify(serializeAiPluginData(left)) ===
+        JSON.stringify(serializeAiPluginData(right)));
+}

package/dist/sessions/session-store.d.ts

@@ -0,0 +1,47 @@
+import type { AiChatItem } from "../chat/chat-items";
+import type { AgentUsage, AiThinkingLevel, ModelRef } from "../core/types";
+export type StoredAgentSession = {
+    id: string;
+    runtime: string;
+    runtimeSessionId: string;
+    workspace?: string;
+    agent?: string;
+    model?: ModelRef;
+    thinking?: AiThinkingLevel;
+    usage?: AgentUsage;
+    createdAt: string;
+    updatedAt: string;
+    interrupted?: boolean;
+    pendingApprovalId?: string;
+    pendingQuestionId?: string;
+    items: AiChatItem[];
+};
+export interface AgentSessionStore {
+    list(): Promise<StoredAgentSession[]>;
+    get(id: string): Promise<StoredAgentSession | undefined>;
+    save(session: StoredAgentSession): Promise<void>;
+    remove(id: string): Promise<void>;
+}
+export declare function createMemorySessionStore(initial?: StoredAgentSession[]): AgentSessionStore;
+export declare function createPersistedSessionStore(options: {
+    read(): Promise<StoredAgentSession[]>;
+    write(sessions: StoredAgentSession[]): Promise<void>;
+}): AgentSessionStore;
+export declare function createStoredAgentSession(input: {
+    id: string;
+    runtime: string;
+    runtimeSessionId: string;
+    workspace?: string;
+    agent?: string;
+    model?: ModelRef;
+    thinking?: AiThinkingLevel;
+    usage?: AgentUsage;
+    items?: AiChatItem[];
+    pendingApprovalId?: string;
+    pendingQuestionId?: string;
+    interrupted?: boolean;
+}): StoredAgentSession;
+export declare function pendingApprovalIdFromItems(items: AiChatItem[]): string | undefined;
+export declare function pendingQuestionIdFromItems(items: AiChatItem[]): string | undefined;
+export declare function interruptPendingApprovals(items: AiChatItem[]): AiChatItem[];
+export declare function interruptPendingInteractions(items: AiChatItem[]): AiChatItem[];

package/dist/sessions/session-store.js

@@ -0,0 +1,117 @@
+export function createMemorySessionStore(initial = []) {
+    const sessions = new Map(initial.map((session) => [session.id, cloneSession(session)]));
+    return {
+        async list() {
+            return [...sessions.values()]
+                .map(cloneSession)
+                .sort((left, right) => right.updatedAt.localeCompare(left.updatedAt));
+        },
+        async get(id) {
+            const session = sessions.get(id);
+            return session ? cloneSession(session) : undefined;
+        },
+        async save(session) {
+            sessions.set(session.id, cloneSession(session));
+        },
+        async remove(id) {
+            sessions.delete(id);
+        },
+    };
+}
+export function createPersistedSessionStore(options) {
+    const memory = createMemorySessionStore();
+    let loaded = false;
+    async function ensureLoaded() {
+        if (loaded)
+            return;
+        for (const session of await options.read()) {
+            await memory.save(session);
+        }
+        loaded = true;
+    }
+    async function persist() {
+        await options.write(await memory.list());
+    }
+    return {
+        async list() {
+            await ensureLoaded();
+            return memory.list();
+        },
+        async get(id) {
+            await ensureLoaded();
+            return memory.get(id);
+        },
+        async save(session) {
+            await ensureLoaded();
+            await memory.save(session);
+            await persist();
+        },
+        async remove(id) {
+            await ensureLoaded();
+            await memory.remove(id);
+            await persist();
+        },
+    };
+}
+export function createStoredAgentSession(input) {
+    const now = new Date().toISOString();
+    return {
+        id: input.id,
+        runtime: input.runtime,
+        runtimeSessionId: input.runtimeSessionId,
+        workspace: input.workspace,
+        agent: input.agent,
+        model: input.model,
+        thinking: input.thinking,
+        usage: input.usage ? { ...input.usage } : undefined,
+        createdAt: now,
+        updatedAt: now,
+        interrupted: input.interrupted,
+        pendingApprovalId: input.pendingApprovalId,
+        pendingQuestionId: input.pendingQuestionId,
+        items: input.items ? input.items.map(sanitizeChatItem) : [],
+    };
+}
+export function pendingApprovalIdFromItems(items) {
+    const pending = items.find((item) => item.type === "approval" && item.status === "pending");
+    return pending?.request.id;
+}
+export function pendingQuestionIdFromItems(items) {
+    const pending = items.find((item) => item.type === "question" && item.status === "pending");
+    return pending?.request.id;
+}
+export function interruptPendingApprovals(items) {
+    return items.map((item) => item.type === "approval" && item.status === "pending"
+        ? { ...item, status: "cancelled" }
+        : item);
+}
+export function interruptPendingInteractions(items) {
+    return items.map((item) => {
+        if (item.type === "approval" && item.status === "pending") {
+            return { ...item, status: "cancelled" };
+        }
+        if (item.type === "question" && item.status === "pending") {
+            return { ...item, status: "cancelled" };
+        }
+        if (item.type === "thinking" && item.state === "streaming") {
+            return { ...item, state: "done" };
+        }
+        if (item.type === "tool" && item.state === "running") {
+            return { ...item, state: "completed" };
+        }
+        return item;
+    });
+}
+function cloneSession(session) {
+    return {
+        ...session,
+        usage: session.usage ? { ...session.usage } : undefined,
+        items: session.items.map(sanitizeChatItem),
+    };
+}
+function sanitizeChatItem(item) {
+    if (item.type !== "approval")
+        return { ...item };
+    const { metadata: _vendor, ...request } = item.request;
+    return { ...item, request };
+}

package/dist/settings/acp-agents.d.ts

@@ -0,0 +1,8 @@
+export declare const ACP_AGENT_IDS: readonly ["codex", "cursor"];
+export type AcpAgentId = (typeof ACP_AGENT_IDS)[number];
+export declare const DEFAULT_ACP_AGENT: AcpAgentId;
+export declare function isAcpAgentId(value: unknown): value is AcpAgentId;
+export declare function normalizeAcpAgent(value: unknown): AcpAgentId;
+export declare function catalogModelsForAgent<T extends {
+    provider?: string;
+}>(agent: AcpAgentId, models: T[]): T[];

package/dist/settings/acp-agents.js

@@ -0,0 +1,11 @@
+export const ACP_AGENT_IDS = ["codex", "cursor"];
+export const DEFAULT_ACP_AGENT = "codex";
+export function isAcpAgentId(value) {
+    return ACP_AGENT_IDS.some((id) => id === value);
+}
+export function normalizeAcpAgent(value) {
+    return isAcpAgentId(value) ? value : DEFAULT_ACP_AGENT;
+}
+export function catalogModelsForAgent(agent, models) {
+    return models.filter((model) => model.provider === agent || !model.provider);
+}

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

@@ -0,0 +1,8 @@
+import { PluginSettingTab, type App } from "@lapis-notes/api";
+import type { AiPlugin } from "../ai-plugin";
+export declare class AiSettingsTab extends PluginSettingTab {
+    private readonly aiPlugin;
+    constructor(app: App, aiPlugin: AiPlugin);
+    display(): void;
+    private loadModels;
+}