@lapis-notes/ai 0.1.0

package/dist/catalog/ai-catalog-panel.svelte.d.ts

@@ -0,0 +1,13 @@
+import { type App } from "@lapis-notes/api";
+import { type Component } from "svelte";
+import type { CatalogGroup, CatalogToolRow } from "./types";
+type $$ComponentProps = {
+    app: App;
+    loadCatalog: () => Promise<CatalogGroup[]>;
+    onToggleTool: (tool: CatalogToolRow, enabled: boolean) => Promise<void>;
+    onOpenSkill: (path: string) => Promise<void>;
+    subscribeSettings?: (listener: () => void) => () => void;
+};
+declare const AiCatalogPanel: Component<$$ComponentProps, {}, "">;
+type AiCatalogPanel = ReturnType<typeof AiCatalogPanel>;
+export default AiCatalogPanel;

package/dist/catalog/ai-catalog-view-type.d.ts

@@ -0,0 +1 @@
+export declare const AiCatalogViewType = "ai-catalog";

package/dist/catalog/ai-catalog-view-type.js

@@ -0,0 +1 @@
+export const AiCatalogViewType = "ai-catalog";

package/dist/catalog/ai-catalog-view.d.ts

@@ -0,0 +1,22 @@
+import { View, type WorkspaceLeaf } from "@lapis-notes/api";
+import type { AiPluginSettings } from "../settings/ai-settings";
+import type { CatalogGroup, CatalogToolRow } from "./types";
+export type AiCatalogViewHost = {
+    loadAiCatalog(): Promise<CatalogGroup[]>;
+    setCatalogToolEnabled(tool: CatalogToolRow, enabled: boolean): Promise<void>;
+    openCatalogSkill(path: string): Promise<void>;
+    subscribeSettings(listener: (patch: Partial<AiPluginSettings>) => void): () => void;
+};
+export declare class AiCatalogView extends View {
+    private readonly host;
+    private component;
+    constructor(leaf: WorkspaceLeaf, host: AiCatalogViewHost);
+    getViewType(): string;
+    getDisplayText(): string;
+    getIcon(): string;
+    protected onOpen(): Promise<void>;
+    protected onClose(): Promise<void>;
+    load(): void;
+    unload(): void;
+}
+export { AiCatalogViewType } from "./ai-catalog-view-type";

package/dist/catalog/ai-catalog-view.js

@@ -0,0 +1,48 @@
+import { View } from "@lapis-notes/api";
+import { mount, unmount } from "svelte";
+import AiCatalogPanel from "./ai-catalog-panel.svelte";
+import { AiCatalogViewType } from "./ai-catalog-view-type";
+export class AiCatalogView extends View {
+    host;
+    component = null;
+    constructor(leaf, host) {
+        super(leaf);
+        this.host = host;
+    }
+    getViewType() {
+        return AiCatalogViewType;
+    }
+    getDisplayText() {
+        return "Catalog";
+    }
+    getIcon() {
+        return "library";
+    }
+    onOpen() {
+        return Promise.resolve();
+    }
+    onClose() {
+        return Promise.resolve();
+    }
+    load() {
+        this.unload();
+        this.containerEl.replaceChildren();
+        this.containerEl.classList.add("ai-catalog-view");
+        this.component = mount(AiCatalogPanel, {
+            target: this.containerEl,
+            props: {
+                app: this.app,
+                loadCatalog: () => this.host.loadAiCatalog(),
+                onToggleTool: (tool, enabled) => this.host.setCatalogToolEnabled(tool, enabled),
+                onOpenSkill: (path) => this.host.openCatalogSkill(path),
+                subscribeSettings: (listener) => this.host.subscribeSettings(() => listener()),
+            },
+        });
+    }
+    unload() {
+        if (this.component)
+            void unmount(this.component);
+        this.component = null;
+    }
+}
+export { AiCatalogViewType } from "./ai-catalog-view-type";

package/dist/catalog/filter.d.ts

@@ -0,0 +1,3 @@
+import type { CatalogGroup } from "./types";
+export declare function catalogQueryMatches(query: string, ...fields: readonly (string | undefined)[]): boolean;
+export declare function filterCatalogGroups(groups: readonly CatalogGroup[], query: string): CatalogGroup[];

package/dist/catalog/filter.js

@@ -0,0 +1,24 @@
+export function catalogQueryMatches(query, ...fields) {
+    const needle = query.trim().toLowerCase();
+    if (!needle)
+        return true;
+    return fields.some((field) => field?.toLowerCase().includes(needle));
+}
+export function filterCatalogGroups(groups, query) {
+    if (!query.trim())
+        return [...groups];
+    return groups
+        .map((group) => {
+        const tools = group.tools.filter((tool) => catalogQueryMatches(query, tool.name, tool.description, tool.effect));
+        const commands = group.commands.filter((command) => catalogQueryMatches(query, command.name, `/${command.name}`, command.description));
+        const skills = group.skills.filter((skill) => catalogQueryMatches(query, skill.name, skill.description));
+        const diagnostics = group.diagnostics.filter((diagnostic) => catalogQueryMatches(query, diagnostic.message, diagnostic.path));
+        return { ...group, tools, commands, skills, diagnostics };
+    })
+        .filter((group) => catalogQueryMatches(query, group.label) ||
+        group.tools.length +
+            group.commands.length +
+            group.skills.length +
+            group.diagnostics.length >
+            0);
+}

package/dist/catalog/inventory.d.ts

@@ -0,0 +1,21 @@
+import type { Vault } from "@lapis-notes/api";
+import type { RegisteredAppSkillSource, RegisteredAppSlashCommand, SkillSourceKind } from "@lapis-notes/api/agent-skills";
+import type { RegisteredAppTool } from "@lapis-notes/api/agent-tools";
+import type { UserAgentsCommandStore } from "../commands/user-agents";
+import { type AiPluginSettings } from "../settings/ai-settings";
+import type { LoadedAppSkill } from "../skills/types";
+import type { CatalogGroup, CatalogToolRow } from "./types";
+export interface CollectAiCatalogInput {
+    tools: readonly RegisteredAppTool[];
+    commands: readonly RegisteredAppSlashCommand[];
+    registeredSkills?: readonly RegisteredAppSkillSource[];
+    vault: Vault;
+    bundled: readonly LoadedAppSkill[];
+    settings: AiPluginSettings;
+    pluginLabel: (pluginId: string) => string;
+    userAgents?: UserAgentsCommandStore;
+    scopeDir?: string;
+}
+export declare function collectAiCatalog(input: CollectAiCatalogInput): Promise<CatalogGroup[]>;
+export declare function skillSourceForPath(path: string): SkillSourceKind;
+export declare function catalogToolRows(groups: readonly CatalogGroup[]): CatalogToolRow[];

package/dist/catalog/inventory.js

@@ -0,0 +1,255 @@
+import { SlashCommandCatalog } from "../commands/catalog";
+import { CommandDiscovery } from "../commands/discovery";
+import { isAppToolEnabled, } from "../settings/ai-settings";
+import { BUNDLED_SKILL_NAMES } from "../skills/bundled/research";
+import { parseSkillMarkdown, SkillParseError } from "../skills/parser";
+const SOURCE_RANK = {
+    folder: 5,
+    vault: 4,
+    user: 3,
+    extension: 2,
+    programmatic: 2,
+    bundled: 1,
+};
+export async function collectAiCatalog(input) {
+    const groups = new Map();
+    const pluginGroup = (pluginId) => {
+        const existing = groups.get(pluginId);
+        if (existing)
+            return existing;
+        const created = {
+            id: pluginId,
+            label: input.pluginLabel(pluginId),
+            kind: "plugin",
+            tools: [],
+            commands: [],
+            skills: [],
+            diagnostics: [],
+        };
+        groups.set(pluginId, created);
+        return created;
+    };
+    for (const registered of input.tools) {
+        pluginGroup(registered.owner.pluginId).tools.push({
+            kind: "tool",
+            name: registered.tool.name,
+            description: registered.tool.description,
+            effect: registered.tool.effect,
+            pluginId: registered.owner.pluginId,
+            enabled: isAppToolEnabled({ name: registered.tool.name, owner: registered.owner }, input.settings),
+            owner: registered.owner,
+        });
+    }
+    const discoveredCommands = await new CommandDiscovery({
+        vault: input.vault,
+        userAgents: input.userAgents,
+    }).discover(input.scopeDir ?? "");
+    const catalog = new SlashCommandCatalog();
+    catalog.replaceFileCommands(discoveredCommands.commands, discoveredCommands.overlays);
+    const reserved = catalog.list();
+    const overlayByName = new Map(discoveredCommands.overlays.map((command) => [command.name, command]));
+    for (const command of reserved) {
+        const overlay = overlayByName.get(command.name);
+        pluginGroup("ai").commands.push({
+            kind: "command",
+            name: command.name,
+            description: command.description,
+            source: "app",
+            path: overlay?.path,
+        });
+    }
+    const reservedNames = new Set(reserved.map((command) => command.name));
+    for (const registered of input.commands) {
+        if (reservedNames.has(registered.command.name))
+            continue;
+        pluginGroup(registered.ownerPluginId).commands.push({
+            kind: "command",
+            name: registered.command.name,
+            description: registered.command.description,
+            source: "extension",
+        });
+    }
+    for (const command of discoveredCommands.commands) {
+        const row = {
+            kind: "command",
+            name: command.name,
+            description: command.description,
+            source: command.source,
+            path: command.path,
+        };
+        if (command.source === "user") {
+            ensureNamedGroup(groups, "user", "User", "user").commands.push(row);
+        }
+        else {
+            ensureNamedGroup(groups, "folders", "Folders", "folders").commands.push(row);
+        }
+    }
+    const { skills, diagnostics } = await listInventorySkills(input.vault, input.bundled, input.registeredSkills ?? []);
+    const winners = new Map();
+    for (const skill of skills) {
+        const current = winners.get(skill.name);
+        if (!current || SOURCE_RANK[skill.source] > SOURCE_RANK[current.source]) {
+            winners.set(skill.name, skill);
+        }
+    }
+    for (const skill of skills) {
+        const row = {
+            ...skill,
+            shadowed: winners.get(skill.name) !== skill,
+        };
+        if (skill.source === "folder" || skill.source === "vault") {
+            ensureNamedGroup(groups, "folders", "Folders", "folders").skills.push(row);
+        }
+        else if (skill.source === "user") {
+            ensureNamedGroup(groups, "user", "User", "user").skills.push(row);
+        }
+        else {
+            pluginGroup(skill.pluginId ?? "ai").skills.push(row);
+        }
+    }
+    const listed = [...groups.values()].filter((group) => group.tools.length +
+        group.commands.length +
+        group.skills.length +
+        group.diagnostics.length >
+        0);
+    listed.sort((left, right) => {
+        const order = (kind) => kind === "plugin" ? 0 : kind === "folders" ? 1 : kind === "user" ? 2 : 3;
+        return order(left.kind) - order(right.kind) || left.label.localeCompare(right.label);
+    });
+    const allDiagnostics = [
+        ...diagnostics,
+        ...discoveredCommands.diagnostics,
+    ];
+    if (allDiagnostics.length > 0) {
+        listed.push({
+            id: "diagnostics",
+            label: "Diagnostics",
+            kind: "diagnostics",
+            tools: [],
+            commands: [],
+            skills: [],
+            diagnostics: allDiagnostics,
+        });
+    }
+    return listed;
+}
+function ensureNamedGroup(groups, id, label, kind) {
+    const existing = groups.get(id);
+    if (existing)
+        return existing;
+    const created = {
+        id,
+        label,
+        kind,
+        tools: [],
+        commands: [],
+        skills: [],
+        diagnostics: [],
+    };
+    groups.set(id, created);
+    return created;
+}
+async function listInventorySkills(vault, bundled, registeredSkills) {
+    const skills = [];
+    const diagnostics = [];
+    for (const file of vault.getFilesByGlob("**/.agents/skills/**/SKILL.md")) {
+        if (file.path.includes("/scripts/") || file.path.includes("/references/")) {
+            continue;
+        }
+        const source = skillSourceForPath(file.path);
+        try {
+            const loaded = parseSkillMarkdown(await vault.cachedRead(file), {
+                path: file.path,
+                source,
+                root: file.path.replace(/\/SKILL\.md$/u, ""),
+            });
+            skills.push({
+                kind: "skill",
+                name: loaded.name,
+                description: loaded.description,
+                source,
+                path: file.path,
+                pluginId: source === "bundled" ? "ai" : undefined,
+                shadowed: false,
+                userInvocable: loaded.userInvocable,
+            });
+        }
+        catch (error) {
+            diagnostics.push({
+                path: file.path,
+                message: error instanceof SkillParseError
+                    ? error.message
+                    : "Skill could not be parsed.",
+            });
+        }
+    }
+    for (const file of vault.getFilesByGlob(".agents/user/skills/**/SKILL.md")) {
+        if (file.path.includes("/scripts/") || file.path.includes("/references/")) {
+            continue;
+        }
+        try {
+            const loaded = parseSkillMarkdown(await vault.cachedRead(file), {
+                path: file.path,
+                source: "user",
+                root: file.path.replace(/\/SKILL\.md$/u, ""),
+            });
+            skills.push({
+                kind: "skill",
+                name: loaded.name,
+                description: loaded.description,
+                source: "user",
+                path: file.path,
+                shadowed: false,
+                userInvocable: loaded.userInvocable,
+            });
+        }
+        catch (error) {
+            diagnostics.push({
+                path: file.path,
+                message: error instanceof SkillParseError
+                    ? error.message
+                    : "Skill could not be parsed.",
+            });
+        }
+    }
+    for (const skill of bundled) {
+        if (skills.some((row) => row.name === skill.name && row.source === "bundled")) {
+            continue;
+        }
+        skills.push({
+            kind: "skill",
+            name: skill.name,
+            description: skill.description,
+            source: skill.source,
+            pluginId: "ai",
+            shadowed: false,
+            userInvocable: skill.userInvocable,
+        });
+    }
+    for (const registered of registeredSkills) {
+        if (registered.kind !== "programmatic" || !registered.skill)
+            continue;
+        skills.push({
+            kind: "skill",
+            name: registered.skill.name,
+            description: registered.skill.description,
+            source: "programmatic",
+            pluginId: registered.ownerPluginId,
+            shadowed: false,
+            userInvocable: registered.skill.userInvocable !== false,
+        });
+    }
+    return { skills, diagnostics };
+}
+export function skillSourceForPath(path) {
+    if (path.startsWith(".agents/user/skills/"))
+        return "user";
+    if (path.startsWith(".agents/skills/")) {
+        const name = path.split("/")[2] ?? "";
+        return BUNDLED_SKILL_NAMES.has(name) ? "bundled" : "vault";
+    }
+    return "folder";
+}
+export function catalogToolRows(groups) {
+    return groups.flatMap((group) => group.tools);
+}

package/dist/catalog/tree.d.ts

@@ -0,0 +1,12 @@
+import type { CatalogGroup, CatalogSkillRow } from "./types";
+export type CatalogKindKey = "tools" | "commands" | "skills" | "diagnostics";
+export declare function catalogOwnerKey(groupId: string): string;
+export declare function catalogKindKey(groupId: string, kind: CatalogKindKey): string;
+export declare function catalogToolKey(name: string): string;
+export declare function catalogCommandKey(name: string): string;
+export declare function catalogSkillKey(source: CatalogSkillRow["source"], name: string): string;
+export declare function catalogSkillExpands(_skill: CatalogSkillRow): boolean;
+export declare function collectCatalogFolderKeys(groups: readonly CatalogGroup[]): string[];
+export declare function collectCatalogLeafKeys(groups: readonly CatalogGroup[]): string[];
+export declare function collectCatalogExpandableKeys(groups: readonly CatalogGroup[]): string[];
+export declare function isCatalogFolderKey(key: string): boolean;

package/dist/catalog/tree.js

@@ -0,0 +1,60 @@
+export function catalogOwnerKey(groupId) {
+    return `owner:${groupId}`;
+}
+export function catalogKindKey(groupId, kind) {
+    return `kind:${groupId}:${kind}`;
+}
+export function catalogToolKey(name) {
+    return `leaf:tool:${name}`;
+}
+export function catalogCommandKey(name) {
+    return `leaf:command:${name}`;
+}
+export function catalogSkillKey(source, name) {
+    return `leaf:skill:${source}:${name}`;
+}
+export function catalogSkillExpands(_skill) {
+    return true;
+}
+export function collectCatalogFolderKeys(groups) {
+    const keys = [];
+    for (const group of groups) {
+        keys.push(catalogOwnerKey(group.id));
+        if (group.tools.length > 0) {
+            keys.push(catalogKindKey(group.id, "tools"));
+        }
+        if (group.commands.length > 0) {
+            keys.push(catalogKindKey(group.id, "commands"));
+        }
+        if (group.skills.length > 0) {
+            keys.push(catalogKindKey(group.id, "skills"));
+        }
+        if (group.diagnostics.length > 0) {
+            keys.push(catalogKindKey(group.id, "diagnostics"));
+        }
+    }
+    return keys;
+}
+export function collectCatalogLeafKeys(groups) {
+    const keys = [];
+    for (const group of groups) {
+        for (const tool of group.tools) {
+            keys.push(catalogToolKey(tool.name));
+        }
+        for (const command of group.commands) {
+            keys.push(catalogCommandKey(command.name));
+        }
+        for (const skill of group.skills) {
+            if (catalogSkillExpands(skill)) {
+                keys.push(catalogSkillKey(skill.source, skill.name));
+            }
+        }
+    }
+    return keys;
+}
+export function collectCatalogExpandableKeys(groups) {
+    return [...collectCatalogFolderKeys(groups), ...collectCatalogLeafKeys(groups)];
+}
+export function isCatalogFolderKey(key) {
+    return key.startsWith("owner:") || key.startsWith("kind:");
+}

package/dist/catalog/types.d.ts

@@ -0,0 +1,44 @@
+import type { AppToolEffect } from "@lapis-notes/api/agent-tools";
+import type { SkillSourceKind } from "@lapis-notes/api/agent-skills";
+import type { AppToolEnablementOwner } from "../settings/ai-settings";
+import type { SlashCommandSource } from "../commands/types";
+export type CatalogGroupKind = "plugin" | "folders" | "user" | "diagnostics";
+export interface CatalogToolRow {
+    kind: "tool";
+    name: string;
+    description: string;
+    effect: AppToolEffect;
+    pluginId: string;
+    enabled: boolean;
+    owner: AppToolEnablementOwner;
+}
+export interface CatalogCommandRow {
+    kind: "command";
+    name: string;
+    description: string;
+    source: SlashCommandSource;
+    path?: string;
+}
+export interface CatalogSkillRow {
+    kind: "skill";
+    name: string;
+    description: string;
+    source: SkillSourceKind;
+    path?: string;
+    pluginId?: string;
+    shadowed: boolean;
+    userInvocable: boolean;
+}
+export interface CatalogDiagnosticRow {
+    path: string;
+    message: string;
+}
+export interface CatalogGroup {
+    id: string;
+    label: string;
+    kind: CatalogGroupKind;
+    tools: CatalogToolRow[];
+    commands: CatalogCommandRow[];
+    skills: CatalogSkillRow[];
+    diagnostics: CatalogDiagnosticRow[];
+}

package/dist/catalog/types.js

@@ -0,0 +1 @@
+export {};

package/dist/chat/ai-approval-card.svelte

@@ -0,0 +1,54 @@
+<script lang="ts">
+  import { Badge } from "@lapismd/design-core/shadcn/badge";
+  import type { ApprovalRequest } from "../core/types";
+
+  let {
+    request,
+    disabled = false,
+    onRespond,
+  }: {
+    request: ApprovalRequest;
+    disabled?: boolean;
+    onRespond(optionId: string): void;
+  } = $props();
+</script>
+
+<section
+  class="ai-agent-request"
+  data-ui-component="ai-agent-request"
+  data-kind="permission"
+  data-testid="ai-approval-card"
+>
+  <div data-ui-part="request-heading">
+    <strong>{request.title}</strong>
+    {#if request.tool}
+      <span data-ui-part="tool">{request.tool.name}</span>
+    {/if}
+  </div>
+  {#if request.details?.description || request.details?.path || request.details?.diff}
+    <div data-ui-part="approval-details">
+      {#if request.details.description}
+        <p>{request.details.description}</p>
+      {/if}
+      {#if request.details.path}
+        <code>{request.details.path}</code>
+      {/if}
+      {#if request.details.diff}
+        <pre data-ui-part="approval-diff">{request.details.diff}</pre>
+      {/if}
+    </div>
+  {/if}
+  <div data-ui-part="options">
+    {#each request.options as option, index (option.id)}
+      <button
+        type="button"
+        data-ui-part="feedback-option"
+        disabled={disabled}
+        onclick={() => onRespond(option.id)}
+      >
+        <Badge variant="secondary">{String.fromCharCode(65 + index)}</Badge>
+        <span>{option.label}</span>
+      </button>
+    {/each}
+  </div>
+</section>

package/dist/chat/ai-approval-card.svelte.d.ts

@@ -0,0 +1,9 @@
+import type { ApprovalRequest } from "../core/types";
+type $$ComponentProps = {
+    request: ApprovalRequest;
+    disabled?: boolean;
+    onRespond(optionId: string): void;
+};
+declare const AiApprovalCard: import("svelte").Component<$$ComponentProps, {}, "">;
+type AiApprovalCard = ReturnType<typeof AiApprovalCard>;
+export default AiApprovalCard;