@lapis-notes/ai 0.1.0

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

@@ -0,0 +1,88 @@
+import type { AgentEventSource, ApprovalRequest, UserInputRequest } from "../core/types";
+export type AiChatApprovalStatus = "pending" | "approved" | "rejected" | "answered" | "cancelled";
+export type AiChatItem = ({
+    id: string;
+    type: "message";
+    role: "user" | "assistant";
+    text: string;
+    createdAt?: string;
+} | {
+    id: string;
+    type: "thinking";
+    text: string;
+    kind?: "reasoning" | "summary" | "plan";
+    state: "streaming" | "done";
+    createdAt?: string;
+} | {
+    id: string;
+    type: "tool";
+    toolId: string;
+    name: string;
+    server?: string;
+    state: "running" | "completed" | "error";
+    input?: string;
+    output?: string;
+    createdAt?: string;
+} | {
+    id: string;
+    type: "approval";
+    request: ApprovalRequest;
+    status: AiChatApprovalStatus;
+    responseOptionId?: string;
+    createdAt?: string;
+} | {
+    id: string;
+    type: "question";
+    request: UserInputRequest;
+    status: "pending" | "answered" | "cancelled";
+    createdAt?: string;
+} | {
+    id: string;
+    type: "status";
+    text: string;
+    layout?: "report" | "inventory";
+    inventory?: AiChatInventory;
+    createdAt?: string;
+} | {
+    id: string;
+    type: "error";
+    text: string;
+    createdAt?: string;
+} | {
+    id: string;
+    type: "command";
+    command: string;
+    origin: "app" | "extension" | "skill" | "native-agent";
+    arguments?: string;
+    status: "completed" | "failed" | "cancelled";
+    text: string;
+    createdAt?: string;
+} | {
+    id: string;
+    type: "skill-activation";
+    skillId: string;
+    skillName: string;
+    version: string;
+    origin: "user" | "model" | "app";
+    arguments?: string;
+    text: string;
+    createdAt?: string;
+}) & {
+    agentBindingId?: string;
+    source?: AgentEventSource;
+};
+export type AiChatInventoryKind = "skills" | "tools";
+export type AiChatInventoryItem = {
+    name: string;
+    description?: string;
+    path?: string;
+    kind: "skill" | "tool";
+};
+export type AiChatInventory = {
+    kind: AiChatInventoryKind;
+    items: AiChatInventoryItem[];
+};
+export declare function createChatItemId(prefix: string, index: number): string;
+export declare function isSlashCommandNotice(item: AiChatItem): item is Extract<AiChatItem, {
+    type: "status";
+}>;

package/dist/chat/chat-items.js

@@ -0,0 +1,9 @@
+export function createChatItemId(prefix, index) {
+    return `${prefix}-${index}`;
+}
+export function isSlashCommandNotice(item) {
+    return (item.type === "status" &&
+        (item.layout === "report" ||
+            item.layout === "inventory" ||
+            item.text.includes("\n")));
+}

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

@@ -0,0 +1,15 @@
+export type VaultFileRef = {
+    path: string;
+    name: string;
+};
+export declare function normalizeMentionPath(path: string): string;
+export declare function formatFileMention(path: string): string;
+export declare function extractMentionQuery(input: string): string | null;
+export declare function extractMentionPaths(input: string): string[];
+export declare function mergeAttachmentPaths(...lists: Array<Iterable<string> | undefined>): string[];
+export declare function mentionTokensFromText(text: string): Array<{
+    value: string;
+    label: string;
+    variant: "secondary";
+}>;
+export declare function searchVaultFiles(files: Iterable<VaultFileRef>, query: string, limit?: number): VaultFileRef[];

package/dist/chat/chat-mentions.js

@@ -0,0 +1,77 @@
+import { isLapisInternalPath } from "@lapis-notes/api/path";
+const TRAILING_MENTION_PATTERN = /(^|\s)@(?:"([^"]*)"|([^\s"]*))$/;
+const MENTION_PATTERN = /(^|\s)@(?:"([^"]+)"|([^\s]+))/g;
+export function normalizeMentionPath(path) {
+    const normalized = path.trim().replaceAll("\\", "/");
+    return normalized.startsWith("./") ? normalized.slice(2) : normalized;
+}
+export function formatFileMention(path) {
+    const normalized = normalizeMentionPath(path);
+    return /\s/.test(normalized)
+        ? `@"${normalized.replaceAll('"', '\\"')}"`
+        : `@${normalized}`;
+}
+export function extractMentionQuery(input) {
+    const match = TRAILING_MENTION_PATTERN.exec(input);
+    if (!match)
+        return null;
+    return (match[2] ?? match[3] ?? "").trim();
+}
+export function extractMentionPaths(input) {
+    const paths = [];
+    const seen = new Set();
+    for (const match of input.matchAll(MENTION_PATTERN)) {
+        const path = normalizeMentionPath((match[2] ?? match[3] ?? "").trim());
+        if (!path || seen.has(path))
+            continue;
+        seen.add(path);
+        paths.push(path);
+    }
+    return paths;
+}
+export function mergeAttachmentPaths(...lists) {
+    const seen = new Set();
+    const paths = [];
+    for (const list of lists) {
+        if (!list)
+            continue;
+        for (const raw of list) {
+            const path = normalizeMentionPath(raw);
+            if (!path || seen.has(path))
+                continue;
+            seen.add(path);
+            paths.push(path);
+        }
+    }
+    return paths;
+}
+export function mentionTokensFromText(text) {
+    return extractMentionPaths(text).map((path) => ({
+        value: formatFileMention(path),
+        label: path,
+        variant: "secondary",
+    }));
+}
+export function searchVaultFiles(files, query, limit = 20) {
+    const needle = query.trim().toLowerCase();
+    const matches = [];
+    for (const file of files) {
+        const path = normalizeMentionPath(file.path);
+        if (!path ||
+            path.startsWith("..") ||
+            path.includes("://") ||
+            isLapisInternalPath(path)) {
+            continue;
+        }
+        const name = file.name || path.split("/").at(-1) || path;
+        if (needle &&
+            !path.toLowerCase().includes(needle) &&
+            !name.toLowerCase().includes(needle)) {
+            continue;
+        }
+        matches.push({ path, name });
+        if (matches.length >= limit)
+            break;
+    }
+    return matches;
+}

package/dist/chat/chat-result-views.d.ts

@@ -0,0 +1,5 @@
+import type { App } from "@lapis-notes/api";
+import type { Component } from "svelte";
+import type { AgentResultViewProps } from "@lapis-notes/api";
+export declare function parseToolResultPayload(value?: string): unknown;
+export declare function resolveToolResultView(app: App | undefined, toolName: string | undefined): Component<AgentResultViewProps<App>> | undefined;

package/dist/chat/chat-result-views.js

@@ -0,0 +1,15 @@
+export function parseToolResultPayload(value) {
+    if (value == null || value === "")
+        return undefined;
+    try {
+        return JSON.parse(value);
+    }
+    catch {
+        return value;
+    }
+}
+export function resolveToolResultView(app, toolName) {
+    if (!app || !toolName?.trim())
+        return undefined;
+    return app.agentResultViews?.getByTool(toolName.trim())?.component;
+}

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

@@ -0,0 +1,28 @@
+import type { AgentRuntime, AgentUsage, AiThinkingLevel, ModelRef } from "../core/types";
+import { type AgentSessionStore, type StoredAgentSession } from "../sessions/session-store";
+import type { AiChatItem } from "./chat-items";
+export declare function chatSessionId(workspace?: string, runtime?: string, agent?: string): string;
+export declare function loadStoredChatSession(store: AgentSessionStore | undefined, sessionId: string): Promise<StoredAgentSession | undefined>;
+export declare function applyStoredSessionResumePolicy(input: {
+    stored: StoredAgentSession;
+    runtime: AgentRuntime;
+    resumed: boolean;
+}): {
+    items: AiChatItem[];
+    interrupted: boolean;
+    pendingApprovalId?: string;
+    pendingQuestionId?: string;
+};
+export declare function snapshotStoredChatSession(input: {
+    id: string;
+    runtime: string;
+    runtimeSessionId: string;
+    workspace?: string;
+    agent?: string;
+    model?: ModelRef;
+    thinking?: AiThinkingLevel;
+    usage?: AgentUsage;
+    items: AiChatItem[];
+    createdAt?: string;
+    interrupted?: boolean;
+}): StoredAgentSession;

package/dist/chat/chat-session.js

@@ -0,0 +1,50 @@
+import { interruptPendingInteractions, pendingApprovalIdFromItems, pendingQuestionIdFromItems, } from "../sessions/session-store";
+export function chatSessionId(workspace, runtime, agent) {
+    const base = `ai:${workspace?.trim() || "default"}`;
+    return runtime && agent ? `${base}:${runtime}:${agent}` : base;
+}
+export async function loadStoredChatSession(store, sessionId) {
+    if (!store)
+        return undefined;
+    return store.get(sessionId);
+}
+export function applyStoredSessionResumePolicy(input) {
+    const canResume = Boolean(input.runtime.capabilities().resume && input.runtime.resume);
+    if (canResume && input.resumed) {
+        return {
+            items: [...input.stored.items],
+            interrupted: false,
+            pendingApprovalId: pendingApprovalIdFromItems(input.stored.items),
+            pendingQuestionId: pendingQuestionIdFromItems(input.stored.items),
+        };
+    }
+    const items = interruptPendingInteractions(input.stored.items);
+    return {
+        items,
+        interrupted: Boolean(input.stored.pendingApprovalId ??
+            input.stored.pendingQuestionId ??
+            pendingApprovalIdFromItems(input.stored.items) ??
+            pendingQuestionIdFromItems(input.stored.items)),
+        pendingApprovalId: undefined,
+        pendingQuestionId: undefined,
+    };
+}
+export function snapshotStoredChatSession(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: input.createdAt ?? now,
+        updatedAt: now,
+        interrupted: input.interrupted,
+        pendingApprovalId: pendingApprovalIdFromItems(input.items),
+        pendingQuestionId: pendingQuestionIdFromItems(input.items),
+        items: [...input.items],
+    };
+}

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

@@ -0,0 +1 @@
+export declare function shouldShowWorkingIndicator(initializing: boolean, busy: boolean, error: string | null | undefined): boolean;

package/dist/chat/chat-status.js

@@ -0,0 +1,3 @@
+export function shouldShowWorkingIndicator(initializing, busy, error) {
+    return (initializing || busy) && !error;
+}

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

@@ -0,0 +1,18 @@
+import type { AiChatItem } from "./chat-items";
+import type { AiChatToolItem } from "./chat-tool-display";
+export type ChatTimelineEntry = {
+    kind: "divider";
+    id: string;
+    label: string;
+} | {
+    kind: "item";
+    item: Exclude<AiChatItem, AiChatToolItem>;
+} | {
+    kind: "tools";
+    id: string;
+    items: AiChatToolItem[];
+};
+export declare function formatChatTimestamp(iso: string): string;
+export declare function formatChatRelativeAge(iso: string, now?: Date): string;
+export declare function formatChatDateLabel(iso: string, now?: Date): string;
+export declare function groupChatItemsByDate(items: AiChatItem[], now?: Date, agentLabels?: ReadonlyMap<string, string>): ChatTimelineEntry[];

package/dist/chat/chat-time.js

@@ -0,0 +1,90 @@
+function startOfLocalDay(date) {
+    return new Date(date.getFullYear(), date.getMonth(), date.getDate()).getTime();
+}
+export function formatChatTimestamp(iso) {
+    const date = new Date(iso);
+    if (Number.isNaN(date.getTime()))
+        return "";
+    return new Intl.DateTimeFormat(undefined, {
+        hour: "numeric",
+        minute: "2-digit",
+    }).format(date);
+}
+export function formatChatRelativeAge(iso, now = new Date()) {
+    const date = new Date(iso);
+    if (Number.isNaN(date.getTime()))
+        return "";
+    const delta = Math.max(0, now.getTime() - date.getTime());
+    const minutes = Math.floor(delta / 60_000);
+    if (minutes < 1)
+        return "now";
+    if (minutes < 60)
+        return `${minutes}m`;
+    const hours = Math.floor(minutes / 60);
+    if (hours < 24)
+        return `${hours}h`;
+    const days = Math.floor(hours / 24);
+    if (days < 7)
+        return `${days}d`;
+    return formatChatDateLabel(iso, now);
+}
+export function formatChatDateLabel(iso, now = new Date()) {
+    const date = new Date(iso);
+    if (Number.isNaN(date.getTime()))
+        return "";
+    const day = startOfLocalDay(date);
+    const today = startOfLocalDay(now);
+    const yesterday = today - 86_400_000;
+    if (day === today)
+        return "Today";
+    if (day === yesterday)
+        return "Yesterday";
+    return new Intl.DateTimeFormat(undefined, {
+        month: "long",
+        day: "numeric",
+        year: "numeric",
+    }).format(date);
+}
+export function groupChatItemsByDate(items, now = new Date(), agentLabels = new Map()) {
+    const entries = [];
+    let lastKey = null;
+    let lastBindingId;
+    for (const item of items) {
+        const parsed = item.createdAt ? new Date(item.createdAt) : null;
+        const valid = parsed && !Number.isNaN(parsed.getTime());
+        const key = valid
+            ? String(startOfLocalDay(parsed))
+            : (lastKey ?? String(startOfLocalDay(now)));
+        const labelIso = valid ? item.createdAt : now.toISOString();
+        if (key !== lastKey) {
+            entries.push({
+                kind: "divider",
+                id: `date-${key}`,
+                label: formatChatDateLabel(labelIso, now),
+            });
+            lastKey = key;
+        }
+        if (item.agentBindingId &&
+            item.agentBindingId !== lastBindingId &&
+            agentLabels.has(item.agentBindingId)) {
+            entries.push({
+                kind: "divider",
+                id: `agent-${item.agentBindingId}-${item.id}`,
+                label: agentLabels.get(item.agentBindingId),
+            });
+            lastBindingId = item.agentBindingId;
+        }
+        if (item.type === "tool") {
+            const last = entries.at(-1);
+            if (last?.kind === "tools") {
+                last.items.push(item);
+            }
+            else {
+                entries.push({ kind: "tools", id: `tools-${item.id}`, items: [item] });
+            }
+            continue;
+        }
+        entries.push({ kind: "item", item });
+    }
+    return entries;
+}

package/dist/chat/chat-tool-display.d.ts

@@ -0,0 +1,17 @@
+import type { AiChatItem } from "./chat-items";
+export type AiChatToolItem = Extract<AiChatItem, {
+    type: "tool";
+}>;
+export type ToolPayloadLanguage = "json" | "bash" | "plaintext";
+export type PresentedToolPayload = {
+    code: string;
+    language: ToolPayloadLanguage;
+};
+export type ToolPayloadHint = {
+    toolName?: string;
+    input?: string;
+};
+export declare function presentToolPayload(value?: string, hint?: ToolPayloadHint): PresentedToolPayload | undefined;
+export declare function isOneLineAlert(payload: PresentedToolPayload): boolean;
+export declare function toolCallTarget(input?: string, server?: string): string | undefined;
+export declare function toolCallStatus(state: AiChatToolItem["state"]): "complete" | "error" | "running";

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

@@ -0,0 +1,213 @@
+const SUMMARY_KEYS = [
+    "command",
+    "path",
+    "file",
+    "query",
+    "url",
+    "pattern",
+    "target",
+];
+const PRIMARY_KEYS = [
+    "output",
+    "content",
+    "text",
+    "result",
+    "stdout",
+    "aggregated",
+];
+const METADATA_KEYS = new Set([
+    "ok",
+    "status",
+    "success",
+    "isError",
+    "server",
+    "tool",
+    "name",
+]);
+const STRUCTURAL_SIBLINGS = new Set([
+    "path",
+    "command",
+    "query",
+    "file",
+    "url",
+    "pattern",
+    "target",
+    "locations",
+]);
+const RUNNER_TOOL_NAMES = new Set([
+    "bash",
+    "sh",
+    "shell",
+    "exec",
+    "command",
+    "terminal",
+    "run",
+]);
+const MAX_PARSE_DEPTH = 3;
+export function presentToolPayload(value, hint) {
+    if (value == null || value === "")
+        return undefined;
+    const extracted = extractDisplayValue(value, 0);
+    if (extracted == null || extracted === "")
+        return undefined;
+    if (isRecord(extracted) || Array.isArray(extracted)) {
+        return { code: JSON.stringify(extracted, null, 2), language: "json" };
+    }
+    const text = String(extracted);
+    if (!text)
+        return undefined;
+    return { code: text, language: detectTextLanguage(text, hint) };
+}
+export function isOneLineAlert(payload) {
+    return payload.language === "plaintext" && !payload.code.includes("\n");
+}
+export function toolCallTarget(input, server) {
+    const summary = summarizeToolInput(input);
+    return summary || server || undefined;
+}
+export function toolCallStatus(state) {
+    if (state === "completed")
+        return "complete";
+    if (state === "error")
+        return "error";
+    return "running";
+}
+function extractDisplayValue(value, depth) {
+    const parsed = tryParseJson(value);
+    if (parsed === undefined)
+        return value;
+    if (typeof parsed === "string") {
+        if (depth + 1 >= MAX_PARSE_DEPTH)
+            return parsed;
+        return extractDisplayValue(parsed, depth + 1);
+    }
+    if (Array.isArray(parsed) || !isRecord(parsed))
+        return parsed;
+    const mcpText = mcpContentText(parsed);
+    if (mcpText != null)
+        return extractDisplayValue(mcpText, depth + 1);
+    const unwrapped = unwrapEnvelope(parsed);
+    if (unwrapped !== undefined)
+        return extractDisplayValue(unwrapped, depth + 1);
+    return parsed;
+}
+function tryParseJson(value) {
+    if (typeof value !== "string")
+        return value;
+    const trimmed = value.trim();
+    if (!trimmed)
+        return undefined;
+    if (!trimmed.startsWith("{") &&
+        !trimmed.startsWith("[") &&
+        !trimmed.startsWith('"')) {
+        return undefined;
+    }
+    try {
+        return JSON.parse(trimmed);
+    }
+    catch {
+        return undefined;
+    }
+}
+function unwrapEnvelope(record) {
+    const keys = Object.keys(record);
+    const primary = PRIMARY_KEYS.find((key) => record[key] != null && record[key] !== "");
+    if (!primary)
+        return undefined;
+    const rest = keys.filter((key) => key !== primary);
+    if (rest.some((key) => !METADATA_KEYS.has(key)))
+        return undefined;
+    return record[primary];
+}
+function mcpContentText(record) {
+    if (!Array.isArray(record.content) || record.content.length === 0) {
+        return undefined;
+    }
+    const rest = Object.keys(record).filter((key) => key !== "content");
+    if (rest.some((key) => STRUCTURAL_SIBLINGS.has(key)))
+        return undefined;
+    if (rest.some((key) => !METADATA_KEYS.has(key)))
+        return undefined;
+    const parts = record.content.flatMap((entry) => {
+        if (typeof entry === "string" && entry)
+            return [entry];
+        if (isRecord(entry) && typeof entry.text === "string" && entry.text) {
+            return [entry.text];
+        }
+        return [];
+    });
+    return parts.length > 0 ? parts.join("\n") : undefined;
+}
+function detectTextLanguage(text, hint) {
+    if (isRunnerToolName(hint?.toolName))
+        return "bash";
+    if (hasCommandInput(hint?.input))
+        return "bash";
+    if (text.includes("\n"))
+        return "bash";
+    if (looksLikeCli(text))
+        return "bash";
+    return "plaintext";
+}
+function isRunnerToolName(name) {
+    if (!name)
+        return false;
+    const normalized = name.trim().toLowerCase();
+    if (RUNNER_TOOL_NAMES.has(normalized))
+        return true;
+    const leaf = normalized.split(/[:/]/u).at(-1);
+    return leaf != null && RUNNER_TOOL_NAMES.has(leaf);
+}
+function hasCommandInput(input) {
+    if (!input)
+        return false;
+    try {
+        const parsed = JSON.parse(input);
+        return (isRecord(parsed) &&
+            typeof parsed.command === "string" &&
+            parsed.command.trim() !== "");
+    }
+    catch {
+        return false;
+    }
+}
+function looksLikeCli(text) {
+    const trimmed = text.trim();
+    return (/^[$%] /u.test(trimmed) ||
+        /^error:/imu.test(trimmed) ||
+        /\b(?:stderr|exit \d+)\b/iu.test(trimmed) ||
+        /\|/.test(trimmed));
+}
+function summarizeToolInput(input) {
+    if (!input)
+        return undefined;
+    try {
+        const parsed = JSON.parse(input);
+        if (typeof parsed === "string" && parsed.trim())
+            return parsed.trim();
+        if (!isRecord(parsed))
+            return undefined;
+        for (const key of SUMMARY_KEYS) {
+            const value = parsed[key];
+            if (typeof value === "string" && value.trim())
+                return value.trim();
+        }
+        const locations = parsed.locations;
+        if (Array.isArray(locations)) {
+            const first = locations[0];
+            if (isRecord(first) && typeof first.path === "string" && first.path) {
+                return first.path;
+            }
+        }
+    }
+    catch {
+        const line = input.trim().split("\n")[0] ?? "";
+        if (!line)
+            return undefined;
+        return line.length > 80 ? `${line.slice(0, 77)}…` : line;
+    }
+    return undefined;
+}
+function isRecord(value) {
+    return value != null && typeof value === "object" && !Array.isArray(value);
+}

package/dist/chat/chat-tool-identity.d.ts

@@ -0,0 +1,4 @@
+export declare function isGenericToolName(name: string | undefined): boolean;
+export declare function isEmptyToolInput(value: unknown): boolean;
+export declare function preferToolName(current: string | undefined, incoming: string | undefined): string;
+export declare function toolNameFromInput(input: unknown): string | undefined;