@lapis-notes/history 0.1.2 → 0.2.0

package/dist/repository/components/repository-view.js

@@ -0,0 +1,140 @@
+import { historySource, } from "../controllers/history-source.js";
+import { View } from "@lapis-notes/api";
+import { mount, unmount } from "svelte";
+import RepositoryPanel from "./RepositoryPanel.svelte";
+import { openHistoryRevision } from "../controllers/open-history-revision.js";
+import { RestoreController } from "../controllers/restore.js";
+import { createRestoreController } from "./restore-controller.js";
+import { BackgroundWork } from "../controllers/background-work.js";
+import { followBackup } from "../controllers/backup-follow.js";
+export class RepositoryView extends View {
+    plugin;
+    #controller;
+    #component;
+    #source = "backup";
+    #operation;
+    #revision;
+    #unsubscribe;
+    #initialLoad;
+    #stateRequest = 0;
+    #restore;
+    #restoreActivity;
+    #live;
+    constructor(leaf, plugin) {
+        super(leaf);
+        this.plugin = plugin;
+    }
+    getViewType() {
+        return "repository-history";
+    }
+    getDisplayText() {
+        return this.#source === "original"
+            ? "Original repository history"
+            : "Repository history";
+    }
+    getIcon() {
+        return "git-branch";
+    }
+    getState() {
+        return this.#controller
+            ? {
+                source: this.#source,
+                operation: this.#controller.pinned
+                    ? this.#controller.state.operation
+                    : undefined,
+                revision: this.#controller.state.revision?.id,
+            }
+            : {
+                source: this.#source,
+                operation: this.#operation,
+                revision: this.#revision,
+            };
+    }
+    async setState(state) {
+        const source = historySource(state);
+        if (this.#controller && source !== this.#source)
+            throw new Error("Open a separate tab to change history source");
+        this.#source = source;
+        const request = ++this.#stateRequest;
+        const operation = (this.#operation =
+            typeof state.operation === "string" ? state.operation : undefined);
+        const revision = (this.#revision =
+            typeof state.revision === "string" ? state.revision : undefined);
+        const controller = this.#controller;
+        if (controller) {
+            await this.#initialLoad;
+            if (request !== this.#stateRequest)
+                return;
+            if (operation && operation !== controller.state.operation)
+                await controller.selectOperation(operation);
+            if (request !== this.#stateRequest)
+                return;
+            if (revision)
+                await openHistoryRevision(controller, revision);
+        }
+        await super.setState(state);
+    }
+    async onOpen() { }
+    async onClose() { }
+    onload() {
+        this.#controller = this.plugin.createController(this.#source);
+        if (this.#source === "backup" && this.plugin.restoreService) {
+            this.#restore = createRestoreController(this.plugin);
+            this.#restoreActivity = new BackgroundWork(this.app.notifications, this.plugin.id).follow("Restoring file history", {
+                subscribe: (listener) => this.#restore.subscribe((state) => listener({
+                    busy: state.busy,
+                    phase: state.open ? "restoring" : "ready",
+                })),
+            });
+        }
+        this.#unsubscribe = this.#controller.subscribe((state) => {
+            if (state.operation !== undefined &&
+                state.operation !== this.#operation) {
+                this.#operation = state.operation;
+                this.app.workspace.requestSaveLayout({
+                    source: "api",
+                    operation: "repository-history",
+                });
+            }
+        });
+        this.#initialLoad = this.#controller.refresh(this.#operation);
+        void this.#initialLoad.then(() => {
+            if (this.#controller)
+                this.#live = followBackup(this.#source === "backup"
+                    ? this.plugin.backup?.controller
+                    : undefined, this.#controller);
+        });
+        this.#component = mount(RepositoryPanel, {
+            target: this.containerEl,
+            props: {
+                controller: this.#controller,
+                sources: this.plugin.sourcePicker(this.#source, (source) => {
+                    void this.plugin
+                        .open(undefined, undefined, source)
+                        .catch((error) => this.plugin.report(error));
+                }),
+                restore: this.#restore,
+                initialOperation: this.#operation,
+                initialRevision: this.#revision,
+                initialLoad: this.#initialLoad,
+                copyText: (value) => this.plugin.copyIdentifier(value),
+            },
+        });
+    }
+    onunload() {
+        this.#live?.();
+        this.#restore?.close();
+        this.#restoreActivity?.();
+        this.#stateRequest++;
+        this.#unsubscribe?.();
+        if (this.#component)
+            void unmount(this.#component);
+        this.#component = undefined;
+        if (this.#controller)
+            void this.plugin
+                .release(this.#controller)
+                .catch((error) => this.plugin.report(error));
+        this.#controller = undefined;
+        this.#initialLoad = undefined;
+    }
+}

package/dist/repository/components/restore-controller.d.ts

@@ -0,0 +1,9 @@
+import { RestoreController } from "../controllers/restore.js";
+import type { RepositoryPlugin } from "./repository-plugin.js";
+import type { RestoreService } from "../controllers/restore.js";
+export declare const RESTORE_NOTICE = "repository-history:pending-restore";
+export declare function createRestoreController(plugin: RepositoryPlugin, options?: {
+    service?: RestoreService;
+    key?: "pendingRestore" | "pendingRemoteRestore";
+    title?: string;
+}): RestoreController | undefined;

package/dist/repository/components/restore-controller.js

@@ -0,0 +1,44 @@
+import { guardTranscriptReplacement } from "../controllers/transcript-writers.js";
+import { getWorkspaceHostBinding } from "@lapis-notes/api/workspace-host";
+import { RestoreController } from "../controllers/restore.js";
+import { restoreRecovery } from "../controllers/restore-recovery.js";
+import { updateRepositoryData } from "../controllers/plugin-data.js";
+export const RESTORE_NOTICE = "repository-history:pending-restore";
+export function createRestoreController(plugin, options = {}) {
+    const key = options.key ?? "pendingRestore";
+    let original;
+    const service = options.service ?? plugin.restoreService;
+    if (!service)
+        return;
+    const feedback = plugin.feedback(options.title ?? "Restore history", key === "pendingRestore"
+        ? "repository-history:restore"
+        : "repository-history:remote-restore");
+    const controller = new RestoreController(service, (path, action) => guardTranscriptReplacement(plugin.app, path, action), feedback, async (pending) => {
+        if (pending)
+            original = pending.request.request_id;
+        const own = original;
+        const saved = await updateRepositoryData(plugin, (current) => {
+            if (pending)
+                return { [key]: pending };
+            const retained = restoreRecovery(current[key]);
+            return own && retained?.request.request_id === own
+                ? { [key]: null }
+                : {};
+        });
+        if (!saved.pendingRestore && !saved.pendingRemoteRestore) {
+            getWorkspaceHostBinding(plugin.app.workspace).controller.notifications.dismiss(RESTORE_NOTICE);
+            await plugin.app.notifications.clear(RESTORE_NOTICE);
+        }
+    });
+    void plugin
+        .loadData()
+        .then((data) => {
+        const pending = restoreRecovery(data?.[key]);
+        if (pending) {
+            original ??= pending.request.request_id;
+            controller.recover(pending);
+        }
+    })
+        .catch((error) => feedback.report(error));
+    return controller;
+}

package/dist/repository/components/search/search-provider.d.ts

@@ -0,0 +1,3 @@
+import type { IndexedHistoryService } from "../../controllers/indexed-search.js";
+import type { RepositoryPlugin } from "../repository-plugin.js";
+export declare function registerHistoryResultProvider(plugin: RepositoryPlugin, service: IndexedHistoryService): () => Promise<void>;

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;