@lapis-notes/ai 0.1.0

package/dist/chat/chat-tool-identity.js

@@ -0,0 +1,42 @@
+const GENERIC_TOOL_NAMES = new Set(["tool call", "acp_tool", "tool"]);
+export function isGenericToolName(name) {
+    const normalized = name?.trim().toLowerCase() ?? "";
+    return normalized.length === 0 || GENERIC_TOOL_NAMES.has(normalized);
+}
+export function isEmptyToolInput(value) {
+    if (value == null)
+        return true;
+    if (typeof value === "string") {
+        const trimmed = value.trim();
+        return trimmed.length === 0 || trimmed === "{}";
+    }
+    if (Array.isArray(value))
+        return value.length === 0;
+    if (typeof value === "object")
+        return Object.keys(value).length === 0;
+    return false;
+}
+export function preferToolName(current, incoming) {
+    const incomingName = incoming?.trim() ?? "";
+    const currentName = current?.trim() ?? "";
+    if (!incomingName)
+        return currentName || "acp_tool";
+    if (isGenericToolName(incomingName) && currentName && !isGenericToolName(currentName)) {
+        return currentName;
+    }
+    return incomingName;
+}
+export function toolNameFromInput(input) {
+    if (!isRecord(input))
+        return undefined;
+    for (const key of ["name", "toolName", "tool"]) {
+        const value = input[key];
+        if (typeof value === "string" && value.trim() && !isGenericToolName(value)) {
+            return value.trim();
+        }
+    }
+    return undefined;
+}
+function isRecord(value) {
+    return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}

package/dist/chat/chat-trace.d.ts

@@ -0,0 +1,6 @@
+import type { AgentEvent } from "../core/types";
+import { type AiChatItem } from "./chat-items";
+export declare function applyAgentEventToChatItems(items: AiChatItem[], event: AgentEvent, now?: () => string): AiChatItem[];
+export declare function isVisibleAgentStatus(status: string): boolean;
+export declare function markApprovalResponse(items: AiChatItem[], requestId: string, optionId: string): AiChatItem[];
+export declare function markQuestionResponse(items: AiChatItem[], requestId: string): AiChatItem[];

package/dist/chat/chat-trace.js

@@ -0,0 +1,256 @@
+import { APP_TOOL_MCP_SERVER_NAME } from "../tools/mcp-server-registry";
+import { createChatItemId } from "./chat-items";
+import { isEmptyToolInput, isGenericToolName, preferToolName, } from "./chat-tool-identity";
+export function applyAgentEventToChatItems(items, event, now = () => new Date().toISOString()) {
+    const next = [...items];
+    const createdAt = now();
+    const source = event.source ? { source: { ...event.source } } : {};
+    switch (event.type) {
+        case "text": {
+            settleStreamingThinking(next);
+            const last = next.at(-1);
+            if (last?.type === "message" && last.role === "assistant") {
+                next[next.length - 1] = {
+                    ...last,
+                    ...source,
+                    text: `${last.text}${event.text}`,
+                };
+                return next;
+            }
+            next.push({
+                id: createChatItemId("message", next.length + 1),
+                type: "message",
+                role: "assistant",
+                text: event.text,
+                createdAt,
+                ...source,
+            });
+            return next;
+        }
+        case "thinking": {
+            const last = next.at(-1);
+            if (last?.type === "thinking" && last.state === "streaming") {
+                next[next.length - 1] = {
+                    ...last,
+                    text: `${last.text}${event.text}`,
+                    kind: event.kind ?? last.kind,
+                    ...source,
+                };
+                return next;
+            }
+            next.push({
+                id: createChatItemId("thinking", next.length + 1),
+                type: "thinking",
+                text: event.text,
+                kind: event.kind,
+                state: "streaming",
+                createdAt,
+                ...source,
+            });
+            return next;
+        }
+        case "tool.start": {
+            settleStreamingThinking(next);
+            const index = findToolItemIndex(next, event);
+            const input = preferToolInput(undefined, event.input);
+            if (index >= 0) {
+                const current = next[index];
+                if (current?.type === "tool") {
+                    next[index] = {
+                        ...current,
+                        toolId: pairedToolId(current, event.id),
+                        name: preferToolName(current.name, event.name),
+                        server: event.server ?? current.server,
+                        state: "running",
+                        input: preferToolInput(current.input, event.input),
+                        ...source,
+                    };
+                }
+            }
+            else {
+                next.push({
+                    id: event.id,
+                    type: "tool",
+                    toolId: event.id,
+                    name: preferToolName(undefined, event.name),
+                    server: event.server,
+                    state: "running",
+                    input,
+                    createdAt,
+                    ...source,
+                });
+            }
+            return next;
+        }
+        case "tool.end": {
+            settleStreamingThinking(next);
+            const index = findToolItemIndex(next, event);
+            const output = event.error != null
+                ? stringifyUnknown(event.error)
+                : stringifyUnknown(event.output);
+            if (index >= 0) {
+                const current = next[index];
+                if (current?.type === "tool") {
+                    next[index] = {
+                        ...current,
+                        toolId: pairedToolId(current, event.id),
+                        name: preferToolName(current.name, event.name),
+                        server: event.server ?? current.server,
+                        state: event.error != null ? "error" : "completed",
+                        input: preferToolInput(current.input, event.input),
+                        output,
+                        ...source,
+                    };
+                }
+                return next;
+            }
+            next.push({
+                id: event.id,
+                type: "tool",
+                toolId: event.id,
+                name: preferToolName(undefined, event.name),
+                server: event.server,
+                state: event.error != null ? "error" : "completed",
+                input: preferToolInput(undefined, event.input),
+                output,
+                createdAt,
+                ...source,
+            });
+            return next;
+        }
+        case "permission.request": {
+            settleStreamingThinking(next);
+            next.push({
+                id: `approval-${event.request.id}`,
+                type: "approval",
+                request: event.request,
+                status: "pending",
+                createdAt,
+                ...source,
+            });
+            return next;
+        }
+        case "question.request": {
+            settleStreamingThinking(next);
+            next.push({
+                id: `question-${event.request.id}`,
+                type: "question",
+                request: event.request,
+                status: "pending",
+                createdAt,
+                ...source,
+            });
+            return next;
+        }
+        case "status": {
+            if (!isVisibleAgentStatus(event.status))
+                return next;
+            settleStreamingThinking(next);
+            next.push({
+                id: createChatItemId("status", next.length + 1),
+                type: "status",
+                text: event.status,
+                createdAt,
+                ...source,
+            });
+            return next;
+        }
+        case "error": {
+            const settled = next.map((item) => item.type === "thinking" && item.state === "streaming"
+                ? { ...item, state: "done" }
+                : item);
+            settled.push({
+                id: createChatItemId("error", next.length + 1),
+                type: "error",
+                text: event.error.message,
+                createdAt,
+                ...source,
+            });
+            return settled;
+        }
+        case "completed": {
+            return next.map((item) => item.type === "thinking" && item.state === "streaming"
+                ? { ...item, state: "done", ...source }
+                : item);
+        }
+        case "commands.update":
+            return next;
+        default:
+            return next;
+    }
+}
+export function isVisibleAgentStatus(status) {
+    const normalized = status.trim().toLowerCase();
+    return !(/^usage updated(?:\s*:\s*[\d,]+\s*\/\s*[\d,]+)?$/.test(normalized) ||
+        normalized === "session updated" ||
+        /^available commands updated(?:\s*\(\d+\))?$/.test(normalized));
+}
+export function markApprovalResponse(items, requestId, optionId) {
+    return items.map((item) => {
+        if (item.type !== "approval" || item.request.id !== requestId)
+            return item;
+        const denied = optionId.startsWith("deny");
+        return {
+            ...item,
+            status: denied ? "rejected" : "approved",
+            responseOptionId: optionId,
+        };
+    });
+}
+export function markQuestionResponse(items, requestId) {
+    return items.map((item) => item.type === "question" && item.request.id === requestId
+        ? { ...item, status: "answered" }
+        : item);
+}
+function settleStreamingThinking(items) {
+    for (const [index, item] of items.entries()) {
+        if (item.type === "thinking" && item.state === "streaming") {
+            items[index] = { ...item, state: "done" };
+        }
+    }
+}
+function stringifyUnknown(value) {
+    if (value == null)
+        return undefined;
+    if (typeof value === "string")
+        return value;
+    try {
+        return JSON.stringify(value);
+    }
+    catch {
+        return String(value);
+    }
+}
+function preferToolInput(current, incoming) {
+    if (isEmptyToolInput(incoming))
+        return current;
+    return stringifyUnknown(incoming) ?? current;
+}
+function pairedToolId(current, incomingId) {
+    if (current.id === incomingId || current.toolId === incomingId) {
+        return current.toolId;
+    }
+    return incomingId;
+}
+function findToolItemIndex(items, event) {
+    const exact = items.findIndex((item) => item.type === "tool" &&
+        (item.toolId === event.id || item.id === event.id));
+    if (exact >= 0)
+        return exact;
+    const incomingApp = event.server === APP_TOOL_MCP_SERVER_NAME;
+    const incomingGeneric = !incomingApp &&
+        isGenericToolName(event.name) &&
+        isEmptyToolInput(event.input);
+    if (incomingApp) {
+        return items.findIndex((item) => item.type === "tool" &&
+            item.server !== APP_TOOL_MCP_SERVER_NAME &&
+            isGenericToolName(item.name) &&
+            item.id === item.toolId);
+    }
+    if (incomingGeneric) {
+        return items.findIndex((item) => item.type === "tool" &&
+            item.server === APP_TOOL_MCP_SERVER_NAME &&
+            item.id === item.toolId);
+    }
+    return -1;
+}

package/dist/chat/live-runtime-unavailable.d.ts

@@ -0,0 +1 @@
+export declare const LIVE_RUNTIME_UNAVAILABLE_REASON = "The local agent server is not connected. Start it, then set its URL, port, and token in Settings.";

package/dist/chat/live-runtime-unavailable.js

@@ -0,0 +1 @@
+export const LIVE_RUNTIME_UNAVAILABLE_REASON = "The local agent server is not connected. Start it, then set its URL, port, and token in Settings.";

package/dist/commands/agent.d.ts

@@ -0,0 +1,8 @@
+import type { AcpAgentId } from "../settings/acp-agents";
+export type ComposerAgentSelection = {
+    agent: AcpAgentId;
+    runtimePreference: "acp" | "codex-native" | "fake";
+    label: string;
+};
+export declare function composerAgentLabel(agent?: string, runtimePreference?: string): string;
+export declare function parseAgentCommand(raw: string): ComposerAgentSelection | "status" | "unknown";

package/dist/commands/agent.js

@@ -0,0 +1,38 @@
+const KNOWN = {
+    codex: { agent: "codex", runtimePreference: "acp", label: "Codex ACP" },
+    "codex-acp": {
+        agent: "codex",
+        runtimePreference: "acp",
+        label: "Codex ACP",
+    },
+    cursor: { agent: "cursor", runtimePreference: "acp", label: "Cursor ACP" },
+    "cursor-acp": {
+        agent: "cursor",
+        runtimePreference: "acp",
+        label: "Cursor ACP",
+    },
+    native: {
+        agent: "codex",
+        runtimePreference: "codex-native",
+        label: "Codex Native",
+    },
+    "codex-native": {
+        agent: "codex",
+        runtimePreference: "codex-native",
+        label: "Codex Native",
+    },
+    fake: { agent: "codex", runtimePreference: "fake", label: "Fake" },
+};
+export function composerAgentLabel(agent, runtimePreference) {
+    if (runtimePreference === "fake")
+        return "Fake";
+    if (runtimePreference === "codex-native")
+        return "Codex Native";
+    return agent === "cursor" ? "Cursor ACP" : "Codex ACP";
+}
+export function parseAgentCommand(raw) {
+    const name = raw.trim().toLowerCase();
+    if (!name)
+        return "status";
+    return KNOWN[name] ?? "unknown";
+}

package/dist/commands/catalog.d.ts

@@ -0,0 +1,18 @@
+import type { AppSlashCommandRegistry } from "@lapis-notes/api/agent-skills";
+import type { NativeAgentCommand, SkillSnapshot } from "../skills/types";
+import type { DiscoveredCommandFile } from "./discovery";
+import type { EffectiveSlashCommand } from "./types";
+export declare class SlashCommandCatalog {
+    #private;
+    private readonly extensions?;
+    constructor(extensions?: AppSlashCommandRegistry | undefined);
+    setFileCommandLoader(loader: (scopeDir: string) => Promise<void>): void;
+    refreshFileCommands(scopeDir: string): Promise<void>;
+    rebuildSkillCommands(snapshot: SkillSnapshot): void;
+    replaceFileCommands(commands: readonly DiscoveredCommandFile[], overlays?: readonly DiscoveredCommandFile[]): void;
+    replaceNativeCommands(agentBindingId: string, commands: readonly NativeAgentCommand[]): void;
+    clearNativeCommands(agentBindingId: string): void;
+    get(name: string, agentBindingId?: string): EffectiveSlashCommand | undefined;
+    list(agentBindingId?: string): EffectiveSlashCommand[];
+    native(agentBindingId: string | undefined, name: string): NativeAgentCommand | undefined;
+}

package/dist/commands/catalog.js

@@ -0,0 +1,115 @@
+import { reservedSlashCommandNames, RESERVED_SLASH_COMMANDS } from "./reserved";
+export class SlashCommandCatalog {
+    extensions;
+    #skillCommands = [];
+    #fileCommands = [];
+    #reservedOverlays = new Map();
+    #loadFiles;
+    #native = new Map();
+    constructor(extensions) {
+        this.extensions = extensions;
+    }
+    setFileCommandLoader(loader) {
+        this.#loadFiles = loader;
+    }
+    async refreshFileCommands(scopeDir) {
+        await this.#loadFiles?.(scopeDir);
+    }
+    rebuildSkillCommands(snapshot) {
+        const reserved = reservedSlashCommandNames();
+        const extensionNames = new Set((this.extensions?.list() ?? []).map((item) => item.command.name));
+        this.#skillCommands = snapshot.skills
+            .filter((skill) => skill.userInvocable)
+            .map((skill) => {
+            const collision = reserved.has(skill.name) || extensionNames.has(skill.name);
+            return {
+                name: skill.name,
+                description: skill.description,
+                argumentHint: skill.argumentHint,
+                source: "skill",
+                dispatch: { kind: "skill", skill: skill.name },
+                disabled: collision,
+            };
+        })
+            .filter((command) => !("disabled" in command && command.disabled));
+    }
+    replaceFileCommands(commands, overlays = []) {
+        this.#fileCommands = commands.map((command) => ({
+            name: command.name,
+            description: command.description,
+            argumentHint: command.argumentHint,
+            aliases: command.aliases,
+            source: command.source,
+            dispatch: command.dispatch,
+        }));
+        this.#reservedOverlays = new Map(overlays.map((command) => [
+            command.name,
+            {
+                description: command.description,
+                argumentHint: command.argumentHint,
+                aliases: command.aliases,
+            },
+        ]));
+    }
+    replaceNativeCommands(agentBindingId, commands) {
+        this.#native.set(agentBindingId, commands.map((command) => ({ ...command })));
+    }
+    clearNativeCommands(agentBindingId) {
+        this.#native.delete(agentBindingId);
+    }
+    get(name, agentBindingId) {
+        return this.list(agentBindingId).find((command) => command.name === name || command.aliases?.includes(name));
+    }
+    list(agentBindingId) {
+        const reserved = reservedSlashCommandNames();
+        const reservedCommands = RESERVED_SLASH_COMMANDS.map((command) => {
+            const overlay = this.#reservedOverlays.get(command.name);
+            return overlay ? { ...command, ...overlay } : command;
+        });
+        const extension = (this.extensions?.list() ?? [])
+            .filter((item) => !reserved.has(item.command.name))
+            .map((item) => ({
+            name: item.command.name,
+            description: item.command.description,
+            argumentHint: item.command.argumentHint,
+            aliases: item.command.aliases,
+            source: "extension",
+            dispatch: item.command.dispatch,
+        }));
+        const extensionNames = new Set(extension.map((command) => command.name));
+        const files = this.#fileCommands.filter((command) => !reserved.has(command.name) && !extensionNames.has(command.name));
+        const fileNames = new Set(files.map((command) => command.name));
+        const skills = this.#skillCommands.filter((command) => !reserved.has(command.name) &&
+            !extensionNames.has(command.name) &&
+            !fileNames.has(command.name));
+        const claimed = new Set([
+            ...reserved,
+            ...extensionNames,
+            ...fileNames,
+            ...skills.map((command) => command.name),
+        ]);
+        const native = (agentBindingId ? this.#native.get(agentBindingId) : undefined)
+            ?.filter((command) => !claimed.has(sanitizeName(command.name)))
+            .map((command) => ({
+            name: sanitizeName(command.name),
+            description: command.description ?? "Current agent command",
+            argumentHint: command.argumentHint,
+            source: "native-agent",
+            dispatch: {
+                kind: "native-agent",
+                nativeName: command.name,
+            },
+        }));
+        return [...reservedCommands, ...extension, ...files, ...skills, ...(native ?? [])];
+    }
+    native(agentBindingId, name) {
+        if (!agentBindingId)
+            return undefined;
+        return this.#native
+            .get(agentBindingId)
+            ?.find((command) => sanitizeName(command.name) === sanitizeName(name));
+    }
+}
+function sanitizeName(name) {
+    return name.trim().replace(/^\/+/u, "").toLowerCase();
+}

package/dist/commands/discovery.d.ts

@@ -0,0 +1,36 @@
+import type { Vault } from "@lapis-notes/api";
+import type { AppSlashCommandDispatch } from "@lapis-notes/api/agent-skills";
+import { type ParsedCommandFile } from "./markdown";
+import type { SlashCommandSource } from "./types";
+import type { UserAgentsCommandStore } from "./user-agents";
+export type CommandFileSource = "folder" | "vault" | "user";
+export interface DiscoveredCommandFile {
+    name: string;
+    description: string;
+    argumentHint?: string;
+    aliases?: string[];
+    source: CommandFileSource;
+    path?: string;
+    kind: ParsedCommandFile["kind"];
+    dispatch: AppSlashCommandDispatch;
+}
+export interface CommandDiagnostic {
+    path: string;
+    message: string;
+}
+export interface DiscoveredCommands {
+    commands: DiscoveredCommandFile[];
+    overlays: DiscoveredCommandFile[];
+    diagnostics: CommandDiagnostic[];
+}
+export interface CommandDiscoveryOptions {
+    vault: Vault;
+    userAgents?: UserAgentsCommandStore;
+}
+export declare class CommandDiscovery {
+    #private;
+    private readonly options;
+    constructor(options: CommandDiscoveryOptions);
+    discover(scopeDir: string): Promise<DiscoveredCommands>;
+}
+export declare function fileCommandSource(source: CommandFileSource): SlashCommandSource;

package/dist/commands/discovery.js

@@ -0,0 +1,151 @@
+import { commandFileDispatch, commandNameFromFilename, CommandParseError, parseCommandMarkdown, } from "./markdown";
+import { reservedSlashCommandNames } from "./reserved";
+const SOURCE_RANK = {
+    folder: 3,
+    vault: 2,
+    user: 1,
+};
+function commandGlob(prefix) {
+    const root = prefix.replace(/\/$/u, "");
+    return `${root}/*.md`;
+}
+function folderPrefix(scopeDir) {
+    return scopeDir ? `${scopeDir}/.agents/commands` : ".agents/commands";
+}
+export class CommandDiscovery {
+    options;
+    constructor(options) {
+        this.options = options;
+    }
+    async discover(scopeDir) {
+        const diagnostics = [];
+        const collected = [];
+        await this.#collectVault("folder", folderPrefix(scopeDir), collected, diagnostics);
+        await this.#collectVault("vault", ".agents/commands", collected, diagnostics);
+        await this.#collectUser(collected, diagnostics);
+        return mergeCommandFiles(collected, diagnostics);
+    }
+    async #collectVault(source, prefix, collected, diagnostics) {
+        for (const file of this.options.vault.getFilesByGlob(commandGlob(prefix))) {
+            if (file.path.includes("/")) {
+                const parent = file.path.slice(0, file.path.lastIndexOf("/"));
+                if (parent !== prefix)
+                    continue;
+            }
+            const filename = file.path.split("/").pop() ?? file.path;
+            const name = commandNameFromFilename(filename);
+            if (!name) {
+                diagnostics.push({
+                    path: file.path,
+                    message: "Command file name is not a valid slash command.",
+                });
+                continue;
+            }
+            try {
+                const parsed = parseCommandMarkdown(await this.options.vault.cachedRead(file), file.path, name);
+                collected.push({
+                    name: parsed.name,
+                    description: parsed.description,
+                    argumentHint: parsed.argumentHint,
+                    aliases: parsed.aliases,
+                    source,
+                    path: file.path,
+                    kind: parsed.kind,
+                    dispatch: commandFileDispatch(parsed),
+                });
+            }
+            catch (error) {
+                diagnostics.push({
+                    path: file.path,
+                    message: error instanceof CommandParseError
+                        ? error.message
+                        : "Command could not be parsed.",
+                });
+            }
+        }
+    }
+    async #collectUser(collected, diagnostics) {
+        const store = this.options.userAgents;
+        if (!store)
+            return;
+        for (const file of await store.list()) {
+            const path = store.root
+                ? `${store.root.replace(/\/$/u, "")}/${file.name}.md`
+                : `${file.name}.md`;
+            try {
+                const parsed = parseCommandMarkdown(file.content, path, file.name);
+                collected.push({
+                    name: parsed.name,
+                    description: parsed.description,
+                    argumentHint: parsed.argumentHint,
+                    aliases: parsed.aliases,
+                    source: "user",
+                    kind: parsed.kind,
+                    dispatch: commandFileDispatch(parsed),
+                });
+            }
+            catch (error) {
+                diagnostics.push({
+                    path,
+                    message: error instanceof CommandParseError
+                        ? error.message
+                        : "Command could not be parsed.",
+                });
+            }
+        }
+    }
+}
+function mergeCommandFiles(collected, diagnostics) {
+    const reserved = reservedSlashCommandNames();
+    const overlays = [];
+    const prompts = new Map();
+    const seen = new Map();
+    const ranked = [...collected].sort((left, right) => SOURCE_RANK[right.source] - SOURCE_RANK[left.source]);
+    for (const command of ranked) {
+        const path = command.path ?? command.name;
+        if (reserved.has(command.name)) {
+            if (command.kind !== "host") {
+                diagnostics.push({
+                    path,
+                    message: `Reserved command name cannot be overridden: ${command.name}`,
+                });
+                continue;
+            }
+            const existingOverlay = overlays.find((item) => item.name === command.name);
+            if (!existingOverlay)
+                overlays.push(command);
+            continue;
+        }
+        if (command.kind === "host") {
+            diagnostics.push({
+                path,
+                message: `kind: host requires a reserved command name: ${command.name}`,
+            });
+            continue;
+        }
+        const level = seen.get(command.source) ?? new Set();
+        if (level.has(command.name)) {
+            diagnostics.push({
+                path,
+                message: `Duplicate command name at the same precedence: ${command.name}`,
+            });
+            prompts.delete(command.name);
+            continue;
+        }
+        level.add(command.name);
+        seen.set(command.source, level);
+        const existing = prompts.get(command.name);
+        if (existing && SOURCE_RANK[existing.source] >= SOURCE_RANK[command.source]) {
+            continue;
+        }
+        prompts.set(command.name, command);
+    }
+    return {
+        commands: [...prompts.values()].sort((left, right) => left.name.localeCompare(right.name)),
+        overlays,
+        diagnostics,
+    };
+}
+export function fileCommandSource(source) {
+    return source;
+}