@lapis-notes/ai 0.1.0

package/dist/conversations/redaction.d.ts

@@ -0,0 +1,13 @@
+declare const MAX_DURABLE_FIELD_BYTES: number;
+export type DurableSanitizationOptions = {
+    vaultRoot?: string;
+    workspaceRoot?: string;
+    knownSecrets?: Iterable<string>;
+};
+export type SanitizedDurableField = {
+    text?: string;
+    redacted: boolean;
+    truncated: boolean;
+};
+export declare function sanitizeDurableField(value: unknown, options?: DurableSanitizationOptions): SanitizedDurableField;
+export { MAX_DURABLE_FIELD_BYTES };

package/dist/conversations/redaction.js

@@ -0,0 +1,94 @@
+const MAX_DURABLE_FIELD_BYTES = 64 * 1024;
+const REDACTED = "[REDACTED]";
+const TRUNCATION_MARKER = "\n...[truncated]";
+const SENSITIVE_KEY = /^(?:authorization|cookie|credentials?|env(?:ironment)?|password|private[_-]?key|secret|token|access[_-]?token|refresh[_-]?token|api[_-]?key)$/iu;
+function sanitizeStructure(value, state) {
+    if (Array.isArray(value)) {
+        return value.map((item) => sanitizeStructure(item, state));
+    }
+    if (value && typeof value === "object") {
+        const output = {};
+        for (const [key, nested] of Object.entries(value)) {
+            if (SENSITIVE_KEY.test(key)) {
+                output[key] = REDACTED;
+                state.redacted = true;
+            }
+            else {
+                output[key] = sanitizeStructure(nested, state);
+            }
+        }
+        return output;
+    }
+    return value;
+}
+function stringify(value) {
+    if (value == null)
+        return undefined;
+    if (typeof value === "string")
+        return value;
+    try {
+        return JSON.stringify(value);
+    }
+    catch {
+        return String(value);
+    }
+}
+function replaceAllLiteral(value, needle, replacement) {
+    return needle ? value.split(needle).join(replacement) : value;
+}
+function truncateUtf8(value) {
+    const encoded = new TextEncoder().encode(value);
+    if (encoded.byteLength <= MAX_DURABLE_FIELD_BYTES) {
+        return { text: value, truncated: false };
+    }
+    const marker = new TextEncoder().encode(TRUNCATION_MARKER);
+    const slice = encoded.slice(0, MAX_DURABLE_FIELD_BYTES - marker.byteLength);
+    return {
+        text: `${new TextDecoder().decode(slice)}${TRUNCATION_MARKER}`,
+        truncated: true,
+    };
+}
+export function sanitizeDurableField(value, options = {}) {
+    const state = { redacted: false };
+    const structured = sanitizeStructure(value, state);
+    const initialText = stringify(structured);
+    if (initialText == null) {
+        return { redacted: state.redacted, truncated: false };
+    }
+    let text = initialText;
+    const replacements = [
+        [options.vaultRoot, "<vault>"],
+        [options.workspaceRoot, "<workspace>"],
+    ];
+    for (const [root, replacement] of replacements) {
+        if (root && text.includes(root)) {
+            text = replaceAllLiteral(text, root, replacement);
+            state.redacted = true;
+        }
+    }
+    for (const secret of options.knownSecrets ?? []) {
+        if (secret && text.includes(secret)) {
+            text = replaceAllLiteral(text, secret, REDACTED);
+            state.redacted = true;
+        }
+    }
+    const patterns = [
+        /-----BEGIN [^-]+ PRIVATE KEY-----[\s\S]*?-----END [^-]+ PRIVATE KEY-----/giu,
+        /\bBearer\s+[A-Za-z0-9._~+/=-]+/giu,
+        /\b(?:api[_-]?key|password|secret|token)\s*[:=]\s*[^\s,;]+/giu,
+        /\bCookie\s*:\s*[^\r\n]+/giu,
+    ];
+    for (const pattern of patterns) {
+        const replaced = text.replace(pattern, REDACTED);
+        if (replaced !== text)
+            state.redacted = true;
+        text = replaced;
+    }
+    const truncated = truncateUtf8(text);
+    return {
+        text: truncated.text,
+        redacted: state.redacted,
+        truncated: truncated.truncated,
+    };
+}
+export { MAX_DURABLE_FIELD_BYTES };

package/dist/conversations/reveal-scope.d.ts

@@ -0,0 +1,3 @@
+import type { App } from "@lapis-notes/api";
+export declare const FILE_EXPLORER_REVEAL_PATH_COMMAND = "lapis-file-explorer:reveal-path";
+export declare function revealConversationScope(app: App | undefined, scopeDir: string): void;

package/dist/conversations/reveal-scope.js

@@ -0,0 +1,8 @@
+export const FILE_EXPLORER_REVEAL_PATH_COMMAND = "lapis-file-explorer:reveal-path";
+export function revealConversationScope(app, scopeDir) {
+    if (!app)
+        return;
+    void app.commands
+        .executeCommand(FILE_EXPLORER_REVEAL_PATH_COMMAND, scopeDir || "/")
+        .catch(() => undefined);
+}

package/dist/conversations/scope-resolver.d.ts

@@ -0,0 +1,11 @@
+import type { TFile } from "@lapis-notes/api/vault";
+export type ConversationScopeResolution = {
+    scopeDir: string;
+    source: "explicit" | "active-file" | "vault-root";
+};
+export declare class ConversationScopeResolver {
+    resolve(input: {
+        explicitFolder?: string | null;
+        activeFile?: Pick<TFile, "path"> | null;
+    }): ConversationScopeResolution;
+}

package/dist/conversations/scope-resolver.js

@@ -0,0 +1,18 @@
+import { conversationScopeForActiveFile, normalizeConversationScope, } from "./paths";
+export class ConversationScopeResolver {
+    resolve(input) {
+        if (input.explicitFolder != null) {
+            return {
+                scopeDir: normalizeConversationScope(input.explicitFolder),
+                source: "explicit",
+            };
+        }
+        if (input.activeFile?.path) {
+            return {
+                scopeDir: conversationScopeForActiveFile(input.activeFile.path),
+                source: "active-file",
+            };
+        }
+        return { scopeDir: "", source: "vault-root" };
+    }
+}

package/dist/conversations/scope-tree.d.ts

@@ -0,0 +1,10 @@
+import type { ConversationListEntry } from "./transcript-store";
+export declare function isScopeInTree(contextDir: string, scopeDir: string): boolean;
+export declare function scopeDepthFromContext(contextDir: string, scopeDir: string): number;
+export declare function formatDirectoryContextLabel(scopeDir: string): string;
+export declare function relativeScopeLabel(contextDir: string, scopeDir: string): string;
+export declare function conversationsInScopeTree(entries: ConversationListEntry[], contextDir: string): ConversationListEntry[];
+export declare function groupConversationsByRelativeScope(entries: ConversationListEntry[], contextDir: string): {
+    heading: string;
+    items: ConversationListEntry[];
+}[];

package/dist/conversations/scope-tree.js

@@ -0,0 +1,71 @@
+import { normalizeConversationScope } from "./paths";
+export function isScopeInTree(contextDir, scopeDir) {
+    const context = normalizeConversationScope(contextDir);
+    const scope = normalizeConversationScope(scopeDir);
+    if (!context)
+        return true;
+    return scope === context || scope.startsWith(`${context}/`);
+}
+export function scopeDepthFromContext(contextDir, scopeDir) {
+    const context = normalizeConversationScope(contextDir);
+    const scope = normalizeConversationScope(scopeDir);
+    if (!context) {
+        return scope ? scope.split("/").length : 0;
+    }
+    if (scope === context)
+        return 0;
+    if (!scope.startsWith(`${context}/`))
+        return Number.POSITIVE_INFINITY;
+    return scope.slice(context.length + 1).split("/").length;
+}
+export function formatDirectoryContextLabel(scopeDir) {
+    const scope = normalizeConversationScope(scopeDir);
+    return scope || "Vault";
+}
+export function relativeScopeLabel(contextDir, scopeDir) {
+    const context = normalizeConversationScope(contextDir);
+    const scope = normalizeConversationScope(scopeDir);
+    if (!scope)
+        return "Vault";
+    if (!context)
+        return scope;
+    if (scope === context)
+        return formatDirectoryContextLabel(context);
+    if (scope.startsWith(`${context}/`))
+        return scope.slice(context.length + 1);
+    return scope;
+}
+export function conversationsInScopeTree(entries, contextDir) {
+    return entries
+        .filter((entry) => {
+        if (entry.metadata?.status === "archived")
+            return false;
+        if (entry.unavailableReason)
+            return false;
+        return isScopeInTree(contextDir, entry.location.scopeDir);
+    })
+        .sort((left, right) => {
+        const depthDelta = scopeDepthFromContext(contextDir, left.location.scopeDir) -
+            scopeDepthFromContext(contextDir, right.location.scopeDir);
+        if (depthDelta !== 0)
+            return depthDelta;
+        const leftUpdated = left.metadata?.updatedAt ?? "";
+        const rightUpdated = right.metadata?.updatedAt ?? "";
+        if (leftUpdated !== rightUpdated) {
+            return rightUpdated.localeCompare(leftUpdated);
+        }
+        return (left.metadata?.title ?? left.location.conversationId).localeCompare(right.metadata?.title ?? right.location.conversationId);
+    });
+}
+export function groupConversationsByRelativeScope(entries, contextDir) {
+    const groups = [];
+    for (const entry of entries) {
+        const heading = relativeScopeLabel(contextDir, entry.location.scopeDir);
+        const last = groups.at(-1);
+        if (last?.heading === heading)
+            last.items.push(entry);
+        else
+            groups.push({ heading, items: [entry] });
+    }
+    return groups;
+}

package/dist/conversations/transcript-projection.d.ts

@@ -0,0 +1,9 @@
+import type { AiChatItem } from "../chat/chat-items";
+import type { DurableSanitizationOptions } from "./redaction";
+import { type TranscriptEntry } from "./types";
+export type TranscriptProjectionOptions = DurableSanitizationOptions & {
+    agentBindingId?: string;
+    now?: () => string;
+};
+export declare function projectChatItemsToTranscript(items: AiChatItem[], options?: TranscriptProjectionOptions): TranscriptEntry[];
+export declare function projectTranscriptToChatItems(entries: TranscriptEntry[]): AiChatItem[];

package/dist/conversations/transcript-projection.js

@@ -0,0 +1,409 @@
+import { sanitizeDurableField } from "./redaction";
+import { CONVERSATION_SCHEMA_VERSION } from "./types";
+function isRuntimeProvenance(value) {
+    return Boolean(value &&
+        typeof value === "object" &&
+        "sessionId" in value &&
+        "runId" in value);
+}
+function runtimeProvenance(value) {
+    return isRuntimeProvenance(value) ? { source: { ...value } } : {};
+}
+function createdAt(item, now) {
+    return item.createdAt ?? now();
+}
+export function projectChatItemsToTranscript(items, options = {}) {
+    const now = options.now ?? (() => new Date().toISOString());
+    return items.flatMap((item) => {
+        const common = {
+            schemaVersion: CONVERSATION_SCHEMA_VERSION,
+            createdAt: createdAt(item, now),
+            ...(options.agentBindingId
+                ? { agentBindingId: options.agentBindingId }
+                : {}),
+            ...runtimeProvenance(item.source),
+        };
+        switch (item.type) {
+            case "message":
+                return [
+                    {
+                        ...common,
+                        id: item.id,
+                        type: "message",
+                        role: item.role,
+                        text: item.text,
+                        provenance: {
+                            originClass: item.role === "user" ? "owner" : "agent",
+                            sourceKind: item.role === "user" ? "user-message" : "assistant-message",
+                        },
+                    },
+                ];
+            case "thinking":
+                if (item.state !== "done" ||
+                    (item.kind !== "summary" && item.kind !== "plan")) {
+                    return [];
+                }
+                return [
+                    {
+                        ...common,
+                        id: item.id,
+                        type: "thinking.summary",
+                        text: item.text,
+                        kind: item.kind,
+                        provenance: {
+                            originClass: "agent",
+                            sourceKind: "runtime-output",
+                        },
+                    },
+                ];
+            case "tool": {
+                if (item.state === "running")
+                    return [];
+                const input = sanitizeDurableField(item.input, options);
+                const output = sanitizeDurableField(item.output, options);
+                return [
+                    {
+                        ...common,
+                        id: item.id,
+                        type: "tool",
+                        toolId: item.toolId,
+                        name: item.name,
+                        server: item.server,
+                        state: item.state,
+                        input: input.text,
+                        output: output.text,
+                        redacted: input.redacted || output.redacted || undefined,
+                        truncated: input.truncated || output.truncated || undefined,
+                        provenance: {
+                            originClass: "untrusted",
+                            sourceKind: "runtime-output",
+                        },
+                    },
+                ];
+            }
+            case "approval": {
+                const toolInput = sanitizeDurableField(item.request.tool?.input, options);
+                const entries = [
+                    {
+                        ...common,
+                        id: `${item.id}:request`,
+                        type: "approval.request",
+                        requestId: item.request.id,
+                        kind: item.request.kind,
+                        title: item.request.title,
+                        tool: item.request.tool
+                            ? { name: item.request.tool.name, input: toolInput.text }
+                            : undefined,
+                        options: item.request.options.map((option) => ({ ...option })),
+                        redacted: toolInput.redacted || undefined,
+                        truncated: toolInput.truncated || undefined,
+                        provenance: {
+                            originClass: "untrusted",
+                            sourceKind: "runtime-output",
+                        },
+                    },
+                ];
+                if (item.responseOptionId) {
+                    const option = item.request.options.find((candidate) => candidate.id === item.responseOptionId);
+                    entries.push({
+                        ...common,
+                        id: `${item.id}:response`,
+                        type: "approval.response",
+                        requestId: item.request.id,
+                        option: {
+                            id: item.responseOptionId,
+                            label: option?.label ?? item.responseOptionId,
+                        },
+                        provenance: {
+                            originClass: "owner",
+                            sourceKind: "owner-response",
+                        },
+                    });
+                }
+                return entries;
+            }
+            case "question": {
+                const entries = [
+                    {
+                        ...common,
+                        id: `${item.id}:request`,
+                        type: "question.request",
+                        requestId: item.request.id,
+                        title: item.request.title,
+                        questions: structuredClone(item.request.questions),
+                        provenance: {
+                            originClass: "agent",
+                            sourceKind: "runtime-output",
+                        },
+                    },
+                ];
+                if (item.status !== "pending") {
+                    entries.push({
+                        ...common,
+                        id: `${item.id}:response`,
+                        type: "question.response",
+                        requestId: item.request.id,
+                        status: item.status,
+                        provenance: {
+                            originClass: "owner",
+                            sourceKind: "owner-response",
+                        },
+                    });
+                }
+                return entries;
+            }
+            case "status":
+                return [
+                    {
+                        ...common,
+                        id: item.id,
+                        type: "system.notice",
+                        text: sanitizeDurableField(item.text, options).text ?? "",
+                        ...(item.layout === "report" || item.layout === "inventory"
+                            ? { layout: item.layout }
+                            : {}),
+                        ...(item.layout === "inventory" && item.inventory
+                            ? { inventory: item.inventory }
+                            : {}),
+                        provenance: {
+                            originClass: "system",
+                            sourceKind: "app-system",
+                        },
+                    },
+                ];
+            case "error":
+                return [
+                    {
+                        ...common,
+                        id: item.id,
+                        type: "error",
+                        message: sanitizeDurableField(item.text, options).text ?? "",
+                        retryable: true,
+                        provenance: {
+                            originClass: "system",
+                            sourceKind: "app-system",
+                        },
+                    },
+                ];
+            case "command":
+                return [
+                    {
+                        ...common,
+                        id: item.id,
+                        type: "command",
+                        command: item.command,
+                        origin: item.origin,
+                        arguments: item.arguments,
+                        status: item.status,
+                        provenance: {
+                            originClass: "system",
+                            sourceKind: "app-system",
+                        },
+                    },
+                ];
+            case "skill-activation":
+                return [
+                    {
+                        ...common,
+                        id: item.id,
+                        type: "skill-activation",
+                        skillId: item.skillId,
+                        skillName: item.skillName,
+                        version: item.version,
+                        origin: item.origin,
+                        arguments: item.arguments,
+                        provenance: {
+                            originClass: item.origin === "user"
+                                ? "owner"
+                                : item.origin === "model"
+                                    ? "agent"
+                                    : "system",
+                            sourceKind: item.origin === "user"
+                                ? "owner-response"
+                                : item.origin === "model"
+                                    ? "runtime-output"
+                                    : "app-system",
+                        },
+                    },
+                ];
+        }
+    });
+}
+export function projectTranscriptToChatItems(entries) {
+    const items = [];
+    const approvals = new Map();
+    const questions = new Map();
+    for (const entry of entries) {
+        switch (entry.type) {
+            case "message":
+                items.push({
+                    id: entry.id,
+                    type: "message",
+                    role: entry.role,
+                    text: entry.text,
+                    createdAt: entry.createdAt,
+                    agentBindingId: entry.agentBindingId,
+                });
+                break;
+            case "thinking.summary":
+                items.push({
+                    id: entry.id,
+                    type: "thinking",
+                    text: entry.text,
+                    kind: entry.kind,
+                    state: "done",
+                    createdAt: entry.createdAt,
+                    agentBindingId: entry.agentBindingId,
+                });
+                break;
+            case "tool":
+                items.push({
+                    id: entry.id,
+                    type: "tool",
+                    toolId: entry.toolId,
+                    name: entry.name,
+                    server: entry.server,
+                    state: entry.state === "cancelled" ? "error" : entry.state,
+                    input: entry.input,
+                    output: entry.output,
+                    createdAt: entry.createdAt,
+                    agentBindingId: entry.agentBindingId,
+                });
+                break;
+            case "approval.request":
+                approvals.set(entry.requestId, items.length);
+                items.push({
+                    id: entry.id.replace(/:request$/u, ""),
+                    type: "approval",
+                    request: {
+                        id: entry.requestId,
+                        kind: entry.kind,
+                        title: entry.title,
+                        tool: entry.tool,
+                        options: structuredClone(entry.options),
+                    },
+                    status: "pending",
+                    createdAt: entry.createdAt,
+                    agentBindingId: entry.agentBindingId,
+                });
+                break;
+            case "approval.response": {
+                const index = approvals.get(entry.requestId);
+                if (index !== undefined) {
+                    const current = items[index];
+                    if (current?.type === "approval") {
+                        items[index] = {
+                            ...current,
+                            status: entry.option.id.startsWith("deny")
+                                ? "rejected"
+                                : "approved",
+                            responseOptionId: entry.option.id,
+                        };
+                    }
+                }
+                break;
+            }
+            case "question.request":
+                questions.set(entry.requestId, items.length);
+                items.push({
+                    id: entry.id.replace(/:request$/u, ""),
+                    type: "question",
+                    request: {
+                        id: entry.requestId,
+                        title: entry.title,
+                        questions: structuredClone(entry.questions),
+                    },
+                    status: "pending",
+                    createdAt: entry.createdAt,
+                    agentBindingId: entry.agentBindingId,
+                });
+                break;
+            case "question.response": {
+                const index = questions.get(entry.requestId);
+                if (index !== undefined) {
+                    const current = items[index];
+                    if (current?.type === "question") {
+                        items[index] = { ...current, status: entry.status };
+                    }
+                }
+                break;
+            }
+            case "system.notice":
+                items.push({
+                    id: entry.id,
+                    type: "status",
+                    text: entry.text,
+                    ...(entry.layout === "report" || entry.layout === "inventory"
+                        ? { layout: entry.layout }
+                        : {}),
+                    ...(entry.layout === "inventory" && entry.inventory
+                        ? { inventory: entry.inventory }
+                        : {}),
+                    createdAt: entry.createdAt,
+                    agentBindingId: entry.agentBindingId,
+                });
+                break;
+            case "error":
+                items.push({
+                    id: entry.id,
+                    type: "error",
+                    text: entry.message,
+                    createdAt: entry.createdAt,
+                    agentBindingId: entry.agentBindingId,
+                });
+                break;
+            case "command":
+                items.push({
+                    id: entry.id,
+                    type: "command",
+                    command: entry.command,
+                    origin: entry.origin,
+                    arguments: entry.arguments,
+                    status: entry.status,
+                    text: `/${entry.command}${entry.arguments ? ` ${entry.arguments}` : ""}`,
+                    createdAt: entry.createdAt,
+                    agentBindingId: entry.agentBindingId,
+                });
+                break;
+            case "skill-activation":
+                items.push({
+                    id: entry.id,
+                    type: "skill-activation",
+                    skillId: entry.skillId,
+                    skillName: entry.skillName,
+                    version: entry.version,
+                    origin: entry.origin,
+                    arguments: entry.arguments,
+                    text: `Skill ${entry.skillName} (${entry.version})`,
+                    createdAt: entry.createdAt,
+                    agentBindingId: entry.agentBindingId,
+                });
+                break;
+            case "agent.switch":
+            case "agent.config":
+                break;
+            case "cancelled": {
+                if (entry.interactionType === "approval" && entry.requestId) {
+                    const index = approvals.get(entry.requestId);
+                    if (index !== undefined) {
+                        const current = items[index];
+                        if (current?.type === "approval") {
+                            items[index] = { ...current, status: "cancelled" };
+                        }
+                    }
+                }
+                if (entry.interactionType === "question" && entry.requestId) {
+                    const index = questions.get(entry.requestId);
+                    if (index !== undefined) {
+                        const current = items[index];
+                        if (current?.type === "question") {
+                            items[index] = { ...current, status: "cancelled" };
+                        }
+                    }
+                }
+                break;
+            }
+        }
+    }
+    return items;
+}

package/dist/conversations/transcript-store.d.ts

@@ -0,0 +1,24 @@
+import type { AgentBindingRecord, ConversationLocation, ConversationMetadata, ConversationSnapshot, TranscriptEntry } from "./types";
+export type ConversationListEntry = {
+    location: ConversationLocation;
+    metadata?: ConversationMetadata;
+    unavailableReason?: string;
+    /** Disposable search-index context. Never written to portable source files. */
+    preview?: string;
+};
+export interface TranscriptStore {
+    create(location: ConversationLocation, metadata: ConversationMetadata): Promise<ConversationSnapshot>;
+    read(location: ConversationLocation): Promise<ConversationSnapshot>;
+    list(scopeDir: string): Promise<ConversationListEntry[]>;
+    listAll(): Promise<ConversationListEntry[]>;
+    writeMetadata(location: ConversationLocation, metadata: ConversationMetadata): Promise<void>;
+    appendAgentRecords(location: ConversationLocation, records: AgentBindingRecord[]): Promise<void>;
+    appendTranscriptEntries(location: ConversationLocation, entries: TranscriptEntry[]): Promise<void>;
+    delete(location: ConversationLocation): Promise<void>;
+}
+export declare function conversationStorageKey(location: ConversationLocation): string;
+export declare function cloneConversationSnapshot(snapshot: ConversationSnapshot): ConversationSnapshot;
+export declare class ConversationWriteQueue {
+    private readonly pending;
+    run<T>(key: string, operation: () => Promise<T>): Promise<T>;
+}