@lapis-notes/ai 0.1.0

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

@@ -0,0 +1,50 @@
+import type { App, WorkspaceLeaf } from "@lapis-notes/api";
+import type { ComposerSearchSource } from "@lapismd/design-core/ai/chat";
+import type { AgentRequest, AgentRuntime, ModelRef, McpServerContribution } from "../core/types";
+import type { AgentSessionStore } from "../sessions/session-store";
+import type { ConversationRepository, CreateConversationInput } from "../conversations/conversation-repository";
+import type { ConversationLocation } from "../conversations/types";
+import { type AiPluginSettings } from "../settings/ai-settings";
+import type { AppToolBridgeCoordinator } from "../tools/desktop-app-tool-bridge";
+import type { SkillRegistry, SkillSnapshotStore } from "../skills/registry";
+import type { SkillDiscoveryContext } from "../skills/types";
+import type { SlashCommandRouter } from "../commands/router";
+import type { AppToolHost } from "../tools/app-tool-host";
+import type { AutomaticMemoryRecall } from "../memory/types";
+import type { HandoffSummaryCoordinator } from "../conversations/handoff-summary";
+type $$ComponentProps = {
+    app?: App;
+    runtime: AgentRuntime;
+    selectRuntime?: (request: AgentRequest) => Promise<AgentRuntime>;
+    unavailableReason?: string | null;
+    initializing?: boolean;
+    workspace?: string;
+    mcpServers?: McpServerContribution[];
+    appToolBridge?: AppToolBridgeCoordinator;
+    skills?: SkillRegistry;
+    skillSnapshots?: SkillSnapshotStore;
+    slashRouter?: SlashCommandRouter;
+    appToolHost?: AppToolHost;
+    memoryRecall?: AutomaticMemoryRecall;
+    handoffSummaries?: Pick<HandoffSummaryCoordinator, "afterTerminal">;
+    skillContext?: () => SkillDiscoveryContext;
+    sessionStore?: AgentSessionStore;
+    sessionId?: string;
+    repository?: ConversationRepository;
+    initialLocation?: ConversationLocation | null;
+    createConversation?: (explicitFolder?: string) => CreateConversationInput;
+    subscribeConversationMoves?: (listener: (oldPath: string, newPath: string) => void) => () => void;
+    onRevealHistory?: () => void | Promise<void>;
+    onConversationLocationChange?: (location: ConversationLocation | null) => void;
+    currentConversationScope?: () => string;
+    listConversationFolders?: () => string[];
+    workspaceLeaf?: WorkspaceLeaf;
+    fileSearch?: ComposerSearchSource;
+    models?: ModelRef[];
+    modelCatalogError?: string | null;
+    settings?: Partial<AiPluginSettings>;
+    onSettingsChange?: (patch: Partial<AiPluginSettings>) => void | Promise<void>;
+};
+declare const AiChatPanel: import("svelte").Component<$$ComponentProps, {}, "">;
+type AiChatPanel = ReturnType<typeof AiChatPanel>;
+export default AiChatPanel;

package/dist/chat/ai-inventory-result.css

@@ -0,0 +1,55 @@
+[data-ui-component="ai-inventory-result"] {
+  display: flex;
+  width: 100%;
+  min-width: 0;
+  flex-direction: column;
+  gap: 0.25rem;
+}
+
+[data-ui-component="ai-inventory-result"] [data-ui-part="empty"] {
+  padding: 0.375rem;
+  color: var(--muted-foreground);
+  font-size: 0.8125rem;
+}
+
+[data-ui-component="ai-inventory-result"] [data-ui-part="item"] {
+  display: flex;
+  min-width: 0;
+  align-items: flex-start;
+  justify-content: space-between;
+  gap: 0.5rem;
+  border-radius: var(--ui-workspace-radius-small, 0.25rem);
+  padding: 0.375rem 0.5rem;
+}
+
+[data-ui-component="ai-inventory-result"] [data-ui-part="item"]:hover,
+[data-ui-component="ai-inventory-result"] [data-ui-part="item"]:focus-within {
+  background: var(
+    --ui-workspace-explorer-row-hover-background,
+    var(--sidebar-accent)
+  );
+}
+
+[data-ui-component="ai-inventory-result"] [data-ui-part="body"] {
+  display: flex;
+  min-width: 0;
+  flex: 1 1 auto;
+  flex-direction: column;
+  gap: 0.125rem;
+}
+
+[data-ui-component="ai-inventory-result"] [data-ui-part="name"] {
+  overflow: hidden;
+  font-weight: 600;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+
+[data-ui-component="ai-inventory-result"] [data-ui-part="description"] {
+  color: var(--muted-foreground);
+  font-size: 0.75rem;
+}
+
+[data-ui-component="ai-inventory-result"] [data-ui-part="open"] {
+  flex: 0 0 auto;
+}

package/dist/chat/ai-inventory-result.svelte

@@ -0,0 +1,63 @@
+<script lang="ts">
+  import type { AgentResultViewProps, App } from "@lapis-notes/api";
+  import { Button } from "@lapismd/design-core/shadcn/button";
+  import SquareArrowOutUpRightIcon from "@lucide/svelte/icons/square-arrow-out-up-right";
+  import type { AiChatInventory, AiChatInventoryItem } from "./chat-items";
+  import "./ai-inventory-result.css";
+
+  let {
+    app,
+    output,
+  }: Partial<AgentResultViewProps<App>> = $props();
+
+  const inventory = $derived.by((): AiChatInventory | undefined => {
+    if (!output || typeof output !== "object" || Array.isArray(output)) {
+      return undefined;
+    }
+    const record = output as Partial<AiChatInventory>;
+    if (record.kind !== "skills" && record.kind !== "tools") return undefined;
+    if (!Array.isArray(record.items)) return undefined;
+    return record as AiChatInventory;
+  });
+
+  async function openItem(item: AiChatInventoryItem): Promise<void> {
+    if (!item.path || !app) return;
+    await app.workspace.openLinkText(item.path, "");
+  }
+</script>
+
+<div
+  data-ui-component="ai-inventory-result"
+  data-kind={inventory?.kind}
+>
+  {#if !inventory || inventory.items.length === 0}
+    <p data-ui-part="empty">
+      {inventory?.kind === "tools"
+        ? "No application tools are available."
+        : "No skills are available."}
+    </p>
+  {:else}
+    {#each inventory.items as item (`${item.kind}:${item.name}:${item.path ?? ""}`)}
+      <div data-ui-part="item">
+        <div data-ui-part="body">
+          <span data-ui-part="name">{item.name}</span>
+          {#if item.description}
+            <span data-ui-part="description">{item.description}</span>
+          {/if}
+        </div>
+        {#if item.path && app}
+          <Button
+            type="button"
+            size="icon-xs"
+            variant="ghost"
+            data-ui-part="open"
+            aria-label={`Open ${item.name}`}
+            onclick={() => void openItem(item)}
+          >
+            <SquareArrowOutUpRightIcon aria-hidden="true" />
+          </Button>
+        {/if}
+      </div>
+    {/each}
+  {/if}
+</div>

package/dist/chat/ai-inventory-result.svelte.d.ts

@@ -0,0 +1,5 @@
+import type { AgentResultViewProps, App } from "@lapis-notes/api";
+import "./ai-inventory-result.css";
+declare const AiInventoryResult: import("svelte").Component<Partial<AgentResultViewProps<App>>, {}, "">;
+type AiInventoryResult = ReturnType<typeof AiInventoryResult>;
+export default AiInventoryResult;

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

@@ -0,0 +1,132 @@
+<script lang="ts">
+  import { Badge } from "@lapismd/design-core/shadcn/badge";
+  import { Button } from "@lapismd/design-core/shadcn/button";
+  import type {
+    UserInputAnswers,
+    UserInputQuestion,
+    UserInputRequest,
+  } from "../core/types";
+
+  let {
+    request,
+    disabled = false,
+    onRespond,
+  }: {
+    request: UserInputRequest;
+    disabled?: boolean;
+    onRespond(answers: UserInputAnswers): void;
+  } = $props();
+
+  let answers = $state<Record<string, string>>({});
+  let otherSelected = $state<Record<string, boolean>>({});
+  const complete = $derived(
+    request.questions.every((question) =>
+      Boolean(answers[question.id]?.trim()),
+    ),
+  );
+
+  function answer(question: UserInputQuestion, value: string): void {
+    answers = { ...answers, [question.id]: value };
+    otherSelected = { ...otherSelected, [question.id]: false };
+  }
+
+  function chooseOther(question: UserInputQuestion): void {
+    answers = { ...answers, [question.id]: "" };
+    otherSelected = { ...otherSelected, [question.id]: true };
+  }
+
+  function updateInput(question: UserInputQuestion, value: string): void {
+    answers = { ...answers, [question.id]: value };
+  }
+
+  function submit(): void {
+    if (disabled || !complete) return;
+    onRespond(
+      Object.fromEntries(
+        request.questions.map((question) => [
+          question.id,
+          [answers[question.id]?.trim() ?? ""],
+        ]),
+      ),
+    );
+  }
+</script>
+
+<form
+  class="ai-agent-request"
+  data-ui-component="ai-agent-request"
+  data-kind="question"
+  data-testid="ai-question-card"
+  onsubmit={(event) => {
+    event.preventDefault();
+    submit();
+  }}
+>
+  {#each request.questions as question (question.id)}
+    <fieldset>
+      <legend>{question.header}</legend>
+      <strong>{question.prompt}</strong>
+      {#if question.options?.length}
+        <div data-ui-part="options">
+          {#each question.options as option, index (option.id)}
+            <button
+              type="button"
+              data-ui-part="feedback-option"
+              data-selected={!otherSelected[question.id] &&
+                answers[question.id] === option.label}
+              disabled={disabled}
+              onclick={() => answer(question, option.label)}
+            >
+              <Badge
+                variant={!otherSelected[question.id] &&
+                answers[question.id] === option.label
+                  ? "default"
+                  : "secondary"}
+                >{String.fromCharCode(65 + index)}</Badge
+              >
+              <span>
+                <span>{option.label}</span>
+                {#if option.description}
+                  <small>{option.description}</small>
+                {/if}
+              </span>
+            </button>
+          {/each}
+          {#if question.allowOther}
+            <button
+              type="button"
+              data-ui-part="feedback-option"
+              data-selected={otherSelected[question.id] === true}
+              disabled={disabled}
+              onclick={() => chooseOther(question)}
+            >
+              <Badge
+                variant={otherSelected[question.id]
+                  ? "default"
+                  : "secondary"}
+                >{String.fromCharCode(65 + question.options.length)}</Badge
+              >
+              <span>Other</span>
+            </button>
+          {/if}
+        </div>
+      {/if}
+      {#if !question.options?.length || otherSelected[question.id]}
+        <input
+          type={question.secret ? "password" : "text"}
+          aria-label={`${question.header} answer`}
+          autocomplete="off"
+          value={answers[question.id] ?? ""}
+          disabled={disabled}
+          oninput={(event) =>
+            updateInput(question, event.currentTarget.value)}
+        />
+      {/if}
+    </fieldset>
+  {/each}
+  <div data-ui-part="request-actions">
+    <Button type="submit" size="sm" disabled={disabled || !complete}
+      >Submit answer</Button
+    >
+  </div>
+</form>

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

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

package/dist/chat/ai-view-bootstrap.d.ts

@@ -0,0 +1,13 @@
+import type { AgentRuntime, ModelRef, McpServerContribution } from "../core/types";
+import type { ConversationLocation } from "../conversations/types";
+import type { AiPluginSettings } from "../settings/ai-settings";
+import type { AiViewHost } from "./ai-view";
+export type AiViewBootstrap = {
+    runtime: AgentRuntime;
+    settings: AiPluginSettings;
+    models: ModelRef[];
+    modelCatalogError: string | null;
+    unavailableReason: string | null;
+};
+export declare function initialAiViewBootstrap(host: AiViewHost): AiViewBootstrap;
+export declare function prepareAiViewBootstrap(host: AiViewHost, initialLocation: ConversationLocation | null, mcpServers: McpServerContribution[]): Promise<AiViewBootstrap>;

package/dist/chat/ai-view-bootstrap.js

@@ -0,0 +1,86 @@
+import { ACP_AGENT_IDS } from "../settings/acp-agents";
+export function initialAiViewBootstrap(host) {
+    return {
+        runtime: host.fallbackRuntime(),
+        settings: host.getSettings(),
+        models: [],
+        modelCatalogError: null,
+        unavailableReason: null,
+    };
+}
+export async function prepareAiViewBootstrap(host, initialLocation, mcpServers) {
+    let settings = host.getSettings();
+    const conversation = initialLocation
+        ? host.conversations.read(initialLocation)
+        : Promise.resolve(null);
+    const catalogs = ACP_AGENT_IDS.map((agent) => host.models.listModels(agent));
+    const [snapshot, settledCatalogs] = await Promise.all([
+        conversation.catch(() => null),
+        Promise.allSettled(catalogs),
+    ]);
+    if (snapshot) {
+        const binding = snapshot.agents.find((record) => record.type === "binding.created" &&
+            record.id === snapshot.metadata.activeAgentBindingId);
+        if (binding?.type === "binding.created") {
+            const agent = binding.agent === "cursor" ? "cursor" : "codex";
+            settings = {
+                ...settings,
+                acpAgent: agent,
+                defaultRuntime: binding.runtime === "codex-native"
+                    ? "codex-native"
+                    : binding.runtime === "fake"
+                        ? "fake"
+                        : "acp",
+                defaultModel: binding.model?.model ?? settings.defaultModels[agent],
+                thinking: binding.thinking ?? settings.thinking,
+            };
+        }
+    }
+    const models = settledCatalogs.flatMap((catalog) => catalog.status === "fulfilled" ? catalog.value : []);
+    let modelCatalogError = null;
+    const selectedCatalog = settledCatalogs[ACP_AGENT_IDS.indexOf(settings.acpAgent)];
+    const agentModels = models.filter((model) => model.provider === settings.acpAgent);
+    if (selectedCatalog?.status === "rejected") {
+        modelCatalogError = errorMessage(selectedCatalog.reason);
+    }
+    else if (!initialLocation &&
+        agentModels.length > 0 &&
+        !agentModels.some((model) => model.model === settings.defaultModel)) {
+        const model = (agentModels.find((entry) => entry.isDefault) ??
+            agentModels[0]);
+        await host.updateSettings({ defaultModel: model.model });
+        settings = host.getSettings();
+    }
+    let runtime;
+    let unavailableReason = null;
+    try {
+        runtime = await host.selectRuntime({
+            prompt: "",
+            mcpServers,
+            agent: settings.acpAgent,
+            model: { provider: settings.acpAgent, model: settings.defaultModel },
+            thinking: settings.thinking,
+            metadata: settings.defaultRuntime === "auto"
+                ? undefined
+                : { runtime: settings.defaultRuntime },
+        });
+        unavailableReason =
+            settings.defaultRuntime === "fake"
+                ? null
+                : host.liveRuntimeUnavailableReason();
+    }
+    catch (error) {
+        runtime = host.fallbackRuntime();
+        unavailableReason = errorMessage(error);
+    }
+    return {
+        runtime,
+        settings,
+        models,
+        modelCatalogError,
+        unavailableReason,
+    };
+}
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}

package/dist/chat/ai-view-panel.svelte

@@ -0,0 +1,89 @@
+<script lang="ts">
+  import { onMount } from "svelte";
+  import type { App, WorkspaceLeaf } from "@lapis-notes/api";
+  import type { ConversationLocation } from "../conversations/types";
+  import AiChatPanel from "./ai-chat-panel.svelte";
+  import type { AiViewHost } from "./ai-view";
+  import {
+    initialAiViewBootstrap,
+    prepareAiViewBootstrap,
+    type AiViewBootstrap,
+  } from "./ai-view-bootstrap";
+
+  let {
+    app,
+    host,
+    workspaceLeaf,
+    initialLocation,
+    onConversationLocationChange,
+  }: {
+    app: App;
+    host: AiViewHost;
+    workspaceLeaf: WorkspaceLeaf;
+    initialLocation: ConversationLocation | null;
+    onConversationLocationChange: (
+      location: ConversationLocation | null,
+    ) => void;
+  } = $props();
+
+  const mcpServers = $derived(host.mcpServers.list());
+  const initialBootstrap = $derived(initialAiViewBootstrap(host));
+  let preparedBootstrap = $state<AiViewBootstrap | null>(null);
+  const bootstrap = $derived(preparedBootstrap ?? initialBootstrap);
+  let initializing = $state(true);
+
+  onMount(() => {
+    let disposed = false;
+    void prepareAiViewBootstrap(host, initialLocation, mcpServers)
+      .then((prepared) => {
+        if (disposed) return;
+        preparedBootstrap = prepared;
+        initializing = false;
+      })
+      .catch((error) => {
+        if (disposed) return;
+        preparedBootstrap = {
+          ...bootstrap,
+          unavailableReason:
+            error instanceof Error ? error.message : String(error),
+        };
+        initializing = false;
+      });
+    return () => {
+      disposed = true;
+    };
+  });
+</script>
+
+<AiChatPanel
+  {app}
+  runtime={bootstrap.runtime}
+  selectRuntime={(request) => host.selectRuntime(request)}
+  unavailableReason={bootstrap.unavailableReason}
+  {initializing}
+  {mcpServers}
+  appToolBridge={host.appToolBridge}
+  skills={host.skills}
+  skillSnapshots={host.skillSnapshots}
+  slashRouter={host.slashRouter}
+  appToolHost={host.appToolHost}
+  memoryRecall={host.memory}
+  handoffSummaries={host.handoffSummaries}
+  skillContext={host.skillContext}
+  workspace={host.workspace}
+  repository={host.conversations}
+  {initialLocation}
+  createConversation={(explicitFolder) =>
+    host.createConversationInput(explicitFolder)}
+  onRevealHistory={() => host.revealConversationHistory()}
+  subscribeConversationMoves={host.subscribeConversationMoves?.bind(host)}
+  {onConversationLocationChange}
+  currentConversationScope={() => host.currentConversationScope()}
+  listConversationFolders={() => host.listConversationFolders()}
+  {workspaceLeaf}
+  fileSearch={host.searchVaultFiles}
+  models={bootstrap.models}
+  modelCatalogError={bootstrap.modelCatalogError}
+  settings={bootstrap.settings}
+  onSettingsChange={(patch) => host.updateSettings(patch)}
+/>

package/dist/chat/ai-view-panel.svelte.d.ts

@@ -0,0 +1,13 @@
+import type { App, WorkspaceLeaf } from "@lapis-notes/api";
+import type { ConversationLocation } from "../conversations/types";
+import type { AiViewHost } from "./ai-view";
+type $$ComponentProps = {
+    app: App;
+    host: AiViewHost;
+    workspaceLeaf: WorkspaceLeaf;
+    initialLocation: ConversationLocation | null;
+    onConversationLocationChange: (location: ConversationLocation | null) => void;
+};
+declare const AiViewPanel: import("svelte").Component<$$ComponentProps, {}, "">;
+type AiViewPanel = ReturnType<typeof AiViewPanel>;
+export default AiViewPanel;

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

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

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

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

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

@@ -0,0 +1,60 @@
+import { View, type ViewStateResult, type WorkspaceLeaf } from "@lapis-notes/api";
+import type { ComposerSearchSource } from "@lapismd/design-core/ai/chat";
+import type { AgentRequest, AgentRuntime, ModelRef, McpServerContribution } from "../core/types";
+import type { ConversationRepository, CreateConversationInput } from "../conversations/conversation-repository";
+import type { AiPluginSettings } from "../settings/ai-settings";
+import type { AppToolBridgeCoordinator } from "../tools/desktop-app-tool-bridge";
+export { AiViewType } from "./ai-view-type";
+export type AiViewHost = {
+    selectRuntime(request: AgentRequest): Promise<AgentRuntime>;
+    fallbackRuntime(): AgentRuntime;
+    liveRuntimeUnavailableReason(): string | null;
+    mcpServers: {
+        list(): McpServerContribution[];
+    };
+    appToolBridge?: AppToolBridgeCoordinator;
+    skills?: import("../skills/registry").SkillRegistry;
+    skillSnapshots?: import("../skills/registry").SkillSnapshotStore;
+    slashRouter?: import("../commands/router").SlashCommandRouter;
+    appToolHost?: import("../tools/app-tool-host").AppToolHost;
+    memory?: import("../memory/types").AutomaticMemoryRecall;
+    handoffSummaries?: Pick<import("../conversations/handoff-summary").HandoffSummaryCoordinator, "afterTerminal">;
+    skillContext?: () => import("../skills/types").SkillDiscoveryContext;
+    conversations: ConversationRepository;
+    createConversationInput(explicitFolder?: string): CreateConversationInput;
+    currentConversationScope(): string;
+    listConversationFolders(): string[];
+    revealConversationHistory(): Promise<void>;
+    subscribeConversationMoves?(listener: (oldPath: string, newPath: string) => void): () => void;
+    searchVaultFiles: ComposerSearchSource;
+    getSettings(): AiPluginSettings;
+    updateSettings(patch: Partial<AiPluginSettings>): Promise<void>;
+    subscribeSettings?(listener: (patch: Partial<AiPluginSettings>) => void): () => void;
+    models: {
+        listModels(provider: string): Promise<ModelRef[]>;
+    };
+    workspace?: string;
+};
+export declare class AiView extends View {
+    private component;
+    private disposed;
+    private mountGeneration;
+    private readonly host;
+    constructor(leaf: WorkspaceLeaf, host: AiViewHost);
+    getViewType(): string;
+    getDisplayText(): string;
+    getIcon(): string;
+    getBreadcrumbFilePath(): string | null;
+    getBreadcrumbs(): {
+        id: string;
+        label: string;
+        onSelect: () => void;
+    }[];
+    protected onOpen(): Promise<void>;
+    protected onClose(): Promise<void>;
+    onload(): void;
+    onunload(): void;
+    setState(state: Record<string, unknown>, result?: ViewStateResult): Promise<void>;
+    private mountPanel;
+    private persistLocationHint;
+}