@lapis-notes/history 0.1.4 → 0.2.0

package/dist/repository/components/search/search-provider.js

@@ -0,0 +1,185 @@
+import { Notice, parseSearchQueryAst, } from "@lapis-notes/api";
+import { BackgroundWork } from "../../controllers/background-work.js";
+import { HistoryIndexController } from "../../controllers/history-index-controller.js";
+import { historyExpression, historyRanges, historyTerms, } from "../../controllers/history-search-expression.js";
+function hitModel(hit, query) {
+    const record = hit.record, checkpoint = record.revision.checkpoint;
+    const path = record.path ?? undefined;
+    const commit = record.deleted
+        ? (record.previous ?? checkpoint.commit)
+        : checkpoint.commit;
+    return {
+        id: `${checkpoint.commit}/${path ?? "checkpoint"}`,
+        groupId: path ?? "checkpoints",
+        path,
+        title: path
+            ? path
+                .split("/")
+                .at(-1)
+                .replace(/\.[^.]+$/, "")
+            : "Checkpoints",
+        extension: path?.split(".").at(-1),
+        timestamp: checkpoint.timestamp_millis,
+        version: {
+            id: checkpoint.commit,
+            label: checkpoint.description.split("\n")[0] || "Saved checkpoint",
+            author: record.revision.author,
+            timestamp: checkpoint.timestamp_millis,
+            contentId: record.content_id ?? undefined,
+        },
+        badges: [
+            path ? "Saved version" : "Checkpoint",
+            ...(record.deleted ? ["Deleted"] : []),
+            ...(record.unavailable ? ["Path only"] : []),
+        ],
+        matches: [
+            {
+                id: "excerpt",
+                field: record.unavailable ? "path" : path ? "content" : "checkpoint",
+                text: hit.excerpt,
+                ranges: historyRanges(hit.excerpt, historyTerms(parseSearchQueryAst(query).expression)),
+                line: hit.line ?? undefined,
+                context: hit.line && path && !record.unavailable && !record.deleted
+                    ? JSON.stringify({ start: hit.line - 1, end: hit.line })
+                    : undefined,
+            },
+        ],
+        target: {
+            operation: checkpoint.operation,
+            commit,
+            ...(path ? { path } : {}),
+            query,
+        },
+    };
+}
+export function registerHistoryResultProvider(plugin, service) {
+    const index = new HistoryIndexController(service, plugin.feedback("History search index", "history-search-index"));
+    const work = new BackgroundWork(plugin.app.notifications, plugin.id);
+    const progress = work.follow("Indexing saved vault history", index);
+    const listeners = new Set();
+    let generation = -1, closed = false, phase = "ready";
+    const changed = index.subscribe((state) => {
+        if ((state.status && generation !== state.status.generation) ||
+            phase !== state.phase) {
+            generation = state.status?.generation ?? generation;
+            phase = state.phase;
+            for (const listener of listeners)
+                listener();
+        }
+    });
+    const activate = async (hit, _match) => {
+        if (closed)
+            throw new Error("History search is closed");
+        if (hit.target.path)
+            await plugin.openBlame(hit.target.operation, hit.target.commit, hit.target.path);
+        else
+            await plugin.open(hit.target.operation, hit.target.commit);
+    };
+    const registration = plugin.registerSearchResultProvider("saved-versions", {
+        label: "Repository history",
+        scope: "history",
+        fields: ["file", "path", "content", "author", "before", "after", "commit"],
+        modes: ["lexical"],
+        subscribe(listener) {
+            listeners.add(listener);
+            return () => {
+                listeners.delete(listener);
+            };
+        },
+        async search(request) {
+            request.signal.throwIfAborted();
+            const page = await work.run("Searching saved vault history", () => service.query({
+                expression: historyExpression(request.query.expression),
+                case_sensitive: request.caseSensitive,
+                cursor: request.cursor ?? null,
+                limit: Math.min(100, request.limit),
+            }));
+            request.signal.throwIfAborted();
+            return {
+                generation: String(page.status.generation),
+                hits: page.hits.map((hit) => hitModel(hit, request.text)),
+                next: page.next ?? undefined,
+                status: {
+                    phase: page.status.complete
+                        ? "ready"
+                        : phase === "paused"
+                            ? "paused"
+                            : "indexing",
+                    description: phase === "paused"
+                        ? "Indexing paused; showing available saved history"
+                        : undefined,
+                    indexed: page.status.indexed,
+                    complete: page.status.complete,
+                    omitted: page.status.omitted,
+                },
+            };
+        },
+        activate,
+        async expand(hit, match, direction, signal) {
+            signal.throwIfAborted();
+            const range = JSON.parse(match.context ?? "{}");
+            const start = direction === "before"
+                ? Math.max(0, Number(range.start) - 5)
+                : Number(range.start);
+            const end = direction === "after" ? Number(range.end) + 5 : Number(range.end);
+            const result = await service.context({
+                commit: hit.target.commit,
+                path: hit.target.path,
+                start,
+                end,
+            });
+            signal.throwIfAborted();
+            return {
+                ...match,
+                text: result.text,
+                line: result.start + 1,
+                ranges: historyRanges(result.text, historyTerms(parseSearchQueryAst(hit.target.query ?? "").expression)),
+                context: result.before || result.after
+                    ? JSON.stringify({ start: result.start, end: result.end })
+                    : undefined,
+            };
+        },
+    });
+    index.start();
+    plugin.app.workspace.onLayoutReady(() => {
+        if (closed)
+            return;
+        plugin.app.workspace.iterateAllLeaves((leaf) => {
+            const view = leaf.getViewState();
+            if (view.type !== "repository-history-search" &&
+                view.state?.__missingViewType !== "repository-history-search")
+                return;
+            void leaf
+                .setViewState({
+                ...view,
+                type: "search",
+                state: {
+                    query: typeof view.state?.query === "string" ? view.state.query : "",
+                    scope: "history",
+                },
+            }, { activatePlugins: false })
+                .catch((error) => plugin.report(error));
+        });
+    });
+    plugin.addCommand({
+        id: "open-history-search",
+        name: "Search saved vault history",
+        callback: () => {
+            if (!plugin.app.plugins.plugins.has("search")) {
+                new Notice("Enable Search to search saved vault history");
+                return;
+            }
+            void plugin.app.commands
+                .executeCommand("search:open-search", "", "history")
+                .catch((error) => plugin.report(error));
+        },
+    });
+    return async () => {
+        closed = true;
+        registration.dispose();
+        changed();
+        await index.close();
+        progress();
+        listeners.clear();
+    };
+}

package/dist/repository/controllers/adoption-controller.d.ts

@@ -0,0 +1,29 @@
+import { type AdoptionService, type AdoptionState, type AdoptionRecovery } from "./adoption.js";
+type Guard = <T>(action: () => Promise<T>) => Promise<T | undefined>;
+/** An explicit ancestry import never replaces current vault files or its source. */
+export declare class AdoptionController {
+    #private;
+    readonly service: AdoptionService;
+    readonly recovery: AdoptionRecovery;
+    readonly feedback: {
+        report(error: unknown): void;
+        recovered(): void;
+    };
+    readonly guard: Guard;
+    constructor(service: AdoptionService, recovery: AdoptionRecovery, feedback: {
+        report(error: unknown): void;
+        recovered(): void;
+    }, guard?: Guard);
+    subscribe(listener: (state: AdoptionState) => void): () => boolean;
+    subscribeActivity(listener: (state: {
+        busy: boolean;
+        phase: string;
+    }) => void): () => boolean;
+    refresh(): Promise<boolean>;
+    adopt(): Promise<boolean>;
+    resume(): Promise<boolean>;
+    stop(): Promise<boolean>;
+    close(): void;
+    drained(): Promise<void>;
+}
+export {};

package/dist/repository/controllers/adoption-controller.js

@@ -0,0 +1,145 @@
+import { adoptionRequest, } from "./adoption.js";
+/** An explicit ancestry import never replaces current vault files or its source. */
+export class AdoptionController {
+    service;
+    recovery;
+    feedback;
+    guard;
+    #state = { busy: false, phase: "ready" };
+    #closed = false;
+    #listeners = new Set();
+    #activity = new Set();
+    #pending = new Set();
+    constructor(service, recovery, feedback, guard = (action) => action()) {
+        this.service = service;
+        this.recovery = recovery;
+        this.feedback = feedback;
+        this.guard = guard;
+    }
+    subscribe(listener) {
+        this.#listeners.add(listener);
+        listener(this.#state);
+        return () => this.#listeners.delete(listener);
+    }
+    subscribeActivity(listener) {
+        this.#activity.add(listener);
+        this.#announce();
+        return () => this.#activity.delete(listener);
+    }
+    #set(patch) {
+        if (this.#closed)
+            return;
+        this.#state = { ...this.#state, ...patch };
+        for (const listener of this.#listeners)
+            listener(this.#state);
+    }
+    #announce() {
+        for (const listener of this.#activity)
+            listener({ busy: this.#pending.size > 0, phase: this.#state.phase });
+    }
+    #run(phase, action) {
+        if (this.#closed || this.#state.busy)
+            return Promise.resolve(false);
+        this.#set({ busy: true, phase });
+        const job = (async () => {
+            try {
+                const accepted = await action();
+                if (accepted !== false && !this.#closed)
+                    this.feedback.recovered();
+                return accepted !== false;
+            }
+            catch (error) {
+                if (!this.#closed)
+                    this.feedback.report(error);
+                return false;
+            }
+            finally {
+                this.#set({ busy: false, phase: "ready" });
+            }
+        })();
+        const tracked = job.finally(() => {
+            this.#pending.delete(tracked);
+            this.#announce();
+        });
+        this.#pending.add(tracked);
+        this.#announce();
+        return tracked;
+    }
+    refresh() {
+        return this.#run("loading", async () => {
+            const request = await this.recovery.load();
+            const data = await this.service.status();
+            this.#set({ data, request: request ?? data.pending ?? undefined });
+            if (data.source_unavailable) {
+                this.feedback.report(new Error("Original repository history could not be inspected. Pending import recovery remains available."));
+                return false;
+            }
+        });
+    }
+    adopt() {
+        if (this.#state.request || !this.#state.data?.source)
+            return Promise.resolve(false);
+        const request = adoptionRequest({
+            request_id: crypto.randomUUID(),
+            source: this.#state.data.source,
+        });
+        return this.#run("importing", async () => {
+            // Recovery uses App-owned file writers, which the native mutation guard
+            // protects too. Prepare before persisting, then reacquire for import.
+            const prepared = await this.guard(async () => !this.#closed);
+            if (prepared !== true)
+                return false;
+            await this.recovery.save(request);
+            this.#set({ request });
+            const data = await this.guard(async () => {
+                if (!this.#closed)
+                    return this.service.adopt(request);
+            });
+            if (!data)
+                return false;
+            await this.recovery.save(undefined);
+            this.#set({ data, request: undefined });
+            return true;
+        });
+    }
+    resume() {
+        const request = this.#state.request;
+        if (!request)
+            return Promise.resolve(false);
+        return this.#run("recovering", async () => {
+            const data = await this.guard(async () => {
+                if (!this.#closed)
+                    return this.service.adopt(request);
+            });
+            if (!data)
+                return false;
+            await this.recovery.save(undefined);
+            this.#set({ data, request: undefined });
+            return true;
+        });
+    }
+    stop() {
+        const request = this.#state.request;
+        if (!request)
+            return Promise.resolve(false);
+        return this.#run("stopping", async () => {
+            const data = await this.guard(async () => {
+                if (!this.#closed)
+                    return this.service.stop(request.request_id);
+            });
+            if (!data)
+                return false;
+            await this.recovery.save(undefined);
+            this.#set({ data, request: undefined });
+            return true;
+        });
+    }
+    close() {
+        this.#closed = true;
+        this.#listeners.clear();
+    }
+    async drained() {
+        while (this.#pending.size)
+            await Promise.allSettled([...this.#pending]);
+    }
+}

package/dist/repository/controllers/adoption.d.ts

@@ -0,0 +1,30 @@
+export type ExistingHistory = {
+    operation: string;
+    commit: string;
+};
+export type AdoptionRequest = {
+    request_id: string;
+    source: ExistingHistory;
+};
+export type AdoptionStatus = {
+    source_unavailable?: boolean;
+    source: ExistingHistory | null;
+    pending: AdoptionRequest | null;
+};
+export interface AdoptionService {
+    status(): Promise<AdoptionStatus>;
+    adopt(request: AdoptionRequest): Promise<AdoptionStatus>;
+    stop(id: string): Promise<AdoptionStatus>;
+}
+export interface AdoptionRecovery {
+    load(): Promise<AdoptionRequest | undefined>;
+    save(request: AdoptionRequest | undefined): Promise<void>;
+}
+export declare function existingHistory(value: unknown): ExistingHistory;
+export declare function adoptionRequest(value: unknown): AdoptionRequest;
+export type AdoptionState = {
+    busy: boolean;
+    phase: string;
+    data?: AdoptionStatus;
+    request?: AdoptionRequest;
+};

package/dist/repository/controllers/adoption.js

@@ -0,0 +1,21 @@
+export function existingHistory(value) {
+    const source = value;
+    if (!source ||
+        typeof source.operation !== "string" ||
+        typeof source.commit !== "string" ||
+        !/^[a-f0-9]{128}$/.test(source.operation) ||
+        !/^[a-f0-9]{40}$/.test(source.commit))
+        throw new Error("Invalid original history selection");
+    return source;
+}
+export function adoptionRequest(value) {
+    const request = value;
+    if (!request ||
+        typeof request.request_id !== "string" ||
+        !/^[a-zA-Z0-9-]{1,128}$/.test(request.request_id))
+        throw new Error("Invalid original history import request");
+    return {
+        request_id: request.request_id,
+        source: existingHistory(request.source),
+    };
+}

package/dist/repository/controllers/ai-history.d.ts

@@ -0,0 +1,57 @@
+import type { App } from "@lapis-notes/api";
+import type { BackupCheckpoint } from "./backup.js";
+import type { HistoryReader } from "./history-reader.js";
+export type AiTurnContext = {
+    conversation: string;
+    turn: string;
+    message: string | null;
+    binding: string | null;
+    session: string | null;
+    agent: string;
+    harness: string;
+    requested_model: string | null;
+    resolved_model: string | null;
+};
+export type AiTurnOutcome = "completed" | "failed" | "cancelled" | "unknown";
+export type AiTurnRecord = {
+    version: 1;
+    context: AiTurnContext;
+    started_at: number;
+    ended_at: number | null;
+    phase: "running" | "complete" | "incomplete";
+    outcome: AiTurnOutcome | null;
+    before: BackupCheckpoint;
+    after: BackupCheckpoint | null;
+};
+export type AiUndoPreview = {
+    paths: string[];
+    expected: string;
+};
+export type AiUndoRequest = AiUndoPreview & {
+    request_id: string;
+    conversation: string;
+    turn: string;
+};
+export interface AiHistoryService {
+    begin(context: AiTurnContext): Promise<AiTurnRecord>;
+    bind(context: AiTurnContext): Promise<AiTurnRecord>;
+    end(conversation: string, turn: string, outcome: AiTurnOutcome): Promise<AiTurnRecord>;
+    list(conversation: string, after?: string): Promise<{
+        records: AiTurnRecord[];
+        next: string | null;
+    }>;
+    read(conversation: string, turn: string): Promise<AiTurnRecord>;
+    previewUndo(conversation: string, turn: string, paths: string[]): Promise<AiUndoPreview>;
+    undo(request: AiUndoRequest): Promise<unknown>;
+    pendingUndo(): Promise<AiUndoRequest[]>;
+}
+export type AiHistoryBinding = {
+    service: AiHistoryService;
+    reader: HistoryReader;
+    enabled(): boolean;
+    guard<T>(action: () => Promise<T>): Promise<T>;
+    reveal(record: AiTurnRecord): Promise<void>;
+};
+export declare function bindAiHistory(app: App, binding: AiHistoryBinding): () => void;
+export declare const ownedAiHistory: (app?: App) => AiHistoryBinding | undefined;
+export declare function parseAiTurn(value: unknown): AiTurnRecord;

package/dist/repository/controllers/ai-history.js

@@ -0,0 +1,51 @@
+const bindings = new WeakMap();
+export function bindAiHistory(app, binding) {
+    if (bindings.has(app))
+        throw new Error("AI history is already bound");
+    bindings.set(app, binding);
+    return () => {
+        if (bindings.get(app) === binding)
+            bindings.delete(app);
+    };
+}
+export const ownedAiHistory = (app) => app ? bindings.get(app) : undefined;
+export function parseAiTurn(value) {
+    const row = value;
+    const checkpoint = (p) => p &&
+        /^[0-9a-f]{40,128}$/u.test(p.commit) &&
+        /^[0-9a-f]{40,128}$/u.test(p.operation) &&
+        typeof p.description === "string" &&
+        Number.isSafeInteger(p.timestamp_millis);
+    if (!row ||
+        row.version !== 1 ||
+        !row.context ||
+        !["running", "complete", "incomplete"].includes(row.phase) ||
+        !Number.isSafeInteger(row.started_at) ||
+        (row.ended_at !== null && !Number.isSafeInteger(row.ended_at)) ||
+        (row.outcome !== null &&
+            !["completed", "failed", "cancelled", "unknown"].includes(row.outcome)) ||
+        (row.phase === "complete" &&
+            (!row.after || !row.outcome || row.outcome === "unknown")) ||
+        !checkpoint(row.before) ||
+        (row.after !== null && !checkpoint(row.after)))
+        throw new Error("Invalid AI history record");
+    for (const id of [row.context.conversation, row.context.turn])
+        if (typeof id !== "string" || !/^[a-zA-Z0-9-]{1,128}$/u.test(id))
+            throw new Error("Invalid AI history identity");
+    for (const text of [
+        row.context.agent,
+        row.context.harness,
+        row.context.message,
+        row.context.binding,
+        row.context.session,
+        row.context.requested_model,
+        row.context.resolved_model,
+    ])
+        if (text !== null &&
+            (typeof text !== "string" ||
+                !text.length ||
+                text.length > 256 ||
+                /[\u0000-\u001f\u007f]/u.test(text)))
+            throw new Error("Invalid AI history context");
+    return row;
+}

package/dist/repository/controllers/author.d.ts

@@ -0,0 +1,2 @@
+/** Display-only lookup; native identities and profile resolution stay host-owned. */
+export declare function reviewGravatar(email: string): Promise<string | undefined>;

package/dist/repository/controllers/author.js

@@ -0,0 +1,11 @@
+/** Display-only lookup; native identities and profile resolution stay host-owned. */
+export async function reviewGravatar(email) {
+    const normalized = email.trim().toLowerCase();
+    if (!/^[^\s@]+@[^\s@]+\.[^\s@]+$/u.test(normalized))
+        return;
+    if (normalized.endsWith("@nostr.invalid"))
+        return;
+    const digest = await crypto.subtle.digest("SHA-256", new TextEncoder().encode(normalized));
+    const hash = Array.from(new Uint8Array(digest), (byte) => byte.toString(16).padStart(2, "0")).join("");
+    return `https://www.gravatar.com/avatar/${hash}?d=404&s=80`;
+}

package/dist/repository/controllers/background-work.d.ts

@@ -0,0 +1,14 @@
+import type { App, NotificationProgressHandle } from "@lapis-notes/api";
+/** App-owned status progress; the caller retains error feedback and lifetime. */
+export declare class BackgroundWork {
+    #private;
+    constructor(notifications: Pick<App["notifications"], "createProgress">, source: string);
+    begin(title: string, message?: string): NotificationProgressHandle;
+    run<T>(title: string, task: () => Promise<T>): Promise<T>;
+    follow(title: string, controller: {
+        subscribe(listener: (state: {
+            busy: boolean;
+            phase: string;
+        }) => void): () => void;
+    }): () => void;
+}

package/dist/repository/controllers/background-work.js

@@ -0,0 +1,57 @@
+import { untrack } from "svelte";
+/** App-owned status progress; the caller retains error feedback and lifetime. */
+export class BackgroundWork {
+    #notifications;
+    #source;
+    constructor(notifications, source) {
+        this.#notifications = notifications;
+        this.#source = source;
+    }
+    begin(title, message) {
+        return untrack(() => this.#notifications.createProgress({
+            title,
+            message,
+            source: this.#source,
+            location: "status",
+            cancellable: false,
+            persistOnComplete: false,
+            persistOnError: false,
+        }));
+    }
+    async run(title, task) {
+        const progress = this.begin(title);
+        try {
+            // Progress publication and imperative task setup must not become inputs
+            // of a Svelte effect that invokes this command.
+            const value = await untrack(task);
+            progress.complete();
+            return value;
+        }
+        catch (error) {
+            progress.fail(error);
+            throw error;
+        }
+    }
+    follow(title, controller) {
+        let progress;
+        const unsubscribe = controller.subscribe((state) => {
+            if (state.busy) {
+                progress ??= this.begin(title);
+                progress.report({
+                    message: state.phase === "loading"
+                        ? "Preparing pinned repository data"
+                        : "Reading repository changes",
+                });
+            }
+            else {
+                progress?.complete();
+                progress = undefined;
+            }
+        });
+        return () => {
+            unsubscribe();
+            progress?.complete();
+            progress = undefined;
+        };
+    }
+}

package/dist/repository/controllers/backup-follow.d.ts

@@ -0,0 +1,5 @@
+import type { BackupController } from "./backup.js";
+/** Coalesce captures while retaining independent, explicitly pinned views. */
+export declare function followBackup(backup: BackupController | undefined, controller: {
+    checkpointChanged(operation: string): Promise<void>;
+}): () => void;

package/dist/repository/controllers/backup-follow.js

@@ -0,0 +1,29 @@
+/** Coalesce captures while retaining independent, explicitly pinned views. */
+export function followBackup(backup, controller) {
+    let closed = false, running = false;
+    let next;
+    const dispose = backup?.subscribe((state) => {
+        if (state.phase !== "ready" || !state.checkpoint)
+            return;
+        next = state.checkpoint.operation;
+        if (!running)
+            void drain();
+    });
+    async function drain() {
+        running = true;
+        try {
+            while (!closed && next) {
+                const operation = next;
+                next = undefined;
+                await controller.checkpointChanged(operation);
+            }
+        }
+        finally {
+            running = false;
+        }
+    }
+    return () => {
+        closed = true;
+        dispose?.();
+    };
+}