@lapis-notes/history 0.1.2 → 0.2.0

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?.();
+    };
+}

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

@@ -0,0 +1,39 @@
+export type BackupCheckpoint = {
+    operation: string;
+    commit: string;
+    change_id: string;
+    description: string;
+    timestamp_millis: number;
+};
+export type BackupStatus = {
+    phase: "saving" | "ready" | "failed" | "closed";
+    checkpoint: BackupCheckpoint | null;
+    error: string | null;
+};
+export interface BackupService {
+    /** Optional native selection persists the setting; start/stop only observe. */
+    setEnabled?(enabled: boolean): Promise<void>;
+    start(changed: (status: BackupStatus) => void): Promise<BackupStatus>;
+    capture(): Promise<BackupStatus>;
+    stop(): Promise<void>;
+}
+/** Plugin owns this independently of the optional status-bar contribution. */
+export declare class BackupController {
+    #private;
+    readonly service: BackupService;
+    readonly feedback: {
+        report(error: unknown): void;
+        recovered(): void;
+    };
+    constructor(service: BackupService, feedback: {
+        report(error: unknown): void;
+        recovered(): void;
+    });
+    subscribe(listener: (status: BackupStatus) => void): () => boolean;
+    start(): Promise<void>;
+    /** Reattach after a cancelled leave without consuming the retained worker. */
+    resume(): Promise<void>;
+    refresh(): Promise<void>;
+    pause(): Promise<void>;
+    close(): Promise<void>;
+}

package/dist/repository/controllers/backup.js

@@ -0,0 +1,129 @@
+/** Plugin owns this independently of the optional status-bar contribution. */
+export class BackupController {
+    #state = { phase: "saving", checkpoint: null, error: null };
+    #listeners = new Set();
+    #closed = false;
+    #running = false;
+    #attempted = false;
+    #epoch = 0;
+    #starting;
+    service;
+    feedback;
+    constructor(service, feedback) {
+        this.service = service;
+        this.feedback = feedback;
+    }
+    subscribe(listener) {
+        this.#listeners.add(listener);
+        listener(this.#state);
+        return () => this.#listeners.delete(listener);
+    }
+    #set(status) {
+        if (this.#closed)
+            return;
+        this.#state = status;
+        if (status.phase === "failed")
+            this.feedback.report(new Error(status.error ?? "Vault backup failed"));
+        else if (status.phase === "ready")
+            this.feedback.recovered();
+        for (const listener of this.#listeners)
+            listener(status);
+    }
+    async start() {
+        await this.#start(true);
+    }
+    /** Reattach after a cancelled leave without consuming the retained worker. */
+    async resume() {
+        await this.#start(false);
+    }
+    async #start(drain) {
+        if (this.#running || this.#closed)
+            return;
+        // A lost response can leave a native owner. Drain it before admitting a
+        // replacement rather than treating an unknown stop as successful.
+        if (drain && this.#attempted)
+            await this.pause();
+        if (this.#closed)
+            return;
+        this.#running = true;
+        this.#attempted = true;
+        const epoch = ++this.#epoch;
+        try {
+            let events = 0;
+            const opening = this.service.start((state) => {
+                if (epoch !== this.#epoch)
+                    return;
+                events++;
+                this.#set(state);
+            });
+            this.#starting = opening;
+            const initial = await opening;
+            if (this.#starting === opening)
+                this.#starting = undefined;
+            if (events === 0 && epoch === this.#epoch)
+                this.#set(initial);
+        }
+        catch (error) {
+            this.#starting = undefined;
+            if (epoch !== this.#epoch)
+                return;
+            this.#running = false;
+            this.#set({
+                ...this.#state,
+                phase: "failed",
+                error: error instanceof Error ? error.message : String(error),
+            });
+        }
+    }
+    async refresh() {
+        if (this.#closed)
+            return;
+        this.#set({ ...this.#state, phase: "saving", error: null });
+        if (!this.#running) {
+            await this.start();
+            return;
+        }
+        const epoch = this.#epoch;
+        try {
+            const result = await this.service.capture();
+            if (epoch === this.#epoch)
+                this.#set(result);
+        }
+        catch (error) {
+            if (epoch !== this.#epoch)
+                return;
+            this.#set({
+                ...this.#state,
+                phase: "failed",
+                error: error instanceof Error ? error.message : String(error),
+            });
+        }
+    }
+    async pause() {
+        this.#epoch++;
+        this.#running = false;
+        try {
+            // A startup already admitted by the host must finish before its stop;
+            // otherwise a late start could outlive the close barrier.
+            if (this.#starting)
+                await Promise.allSettled([this.#starting]);
+            if (this.#attempted)
+                await this.service.stop();
+        }
+        catch (error) {
+            this.#set({
+                ...this.#state,
+                phase: "failed",
+                error: error instanceof Error ? error.message : String(error),
+            });
+            throw error;
+        }
+        this.#attempted = false;
+        this.#set({ ...this.#state, phase: "closed", error: null });
+    }
+    async close() {
+        await this.pause();
+        this.#closed = true;
+        this.#listeners.clear();
+    }
+}

package/dist/repository/controllers/blame-chunks.d.ts

@@ -0,0 +1,13 @@
+import type { BlameRange } from "./blame-model.js";
+export declare const BLAME_UNAVAILABLE = "Blame is not available on this server yet. Source remains available.";
+export declare function sourceLines(contents: string): string[];
+/** Matches the recorded-file admission of the shared JJ annotation adapter. */
+export declare function blameSizeReason(contents: string): string | undefined;
+export interface BlameChunk {
+    start: number;
+    end: number;
+    commitId?: string;
+    continued: boolean;
+}
+/** Split long groups into bounded render chunks, retaining continuation attribution. */
+export declare function blameChunks(lineCount: number, ranges: readonly BlameRange[]): BlameChunk[];

package/dist/repository/controllers/blame-chunks.js

@@ -0,0 +1,51 @@
+export const BLAME_UNAVAILABLE = "Blame is not available on this server yet. Source remains available.";
+export function sourceLines(contents) {
+    if (!contents)
+        return [];
+    const lines = contents.split("\n");
+    if (lines.at(-1) === "")
+        lines.pop();
+    return lines;
+}
+/** Matches the recorded-file admission of the shared JJ annotation adapter. */
+export function blameSizeReason(contents) {
+    return new TextEncoder().encode(contents).byteLength > 256 * 1024 ||
+        sourceLines(contents).length > 32_768
+        ? "Blame is unavailable for files larger than 256 KiB or 32,768 lines."
+        : undefined;
+}
+/** Split long groups into bounded render chunks, retaining continuation attribution. */
+export function blameChunks(lineCount, ranges) {
+    const groups = [];
+    let cursor = 1;
+    for (const native of ranges) {
+        const range = {
+            start: native.start,
+            end: native.end,
+            commitId: native.commit_id,
+        };
+        if (range.start > cursor)
+            groups.push({ start: cursor, end: range.start });
+        const previous = groups.at(-1);
+        if (previous &&
+            previous.commitId === range.commitId &&
+            previous.end === range.start)
+            previous.end = range.end;
+        else
+            groups.push({ ...range });
+        cursor = range.end;
+    }
+    if (cursor <= lineCount)
+        groups.push({ start: cursor, end: lineCount + 1 });
+    return groups.flatMap((group) => {
+        const chunks = [];
+        for (let start = group.start; start < group.end; start += 32)
+            chunks.push({
+                ...group,
+                start,
+                end: Math.min(start + 32, group.end),
+                continued: start !== group.start,
+            });
+        return chunks;
+    });
+}

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

@@ -0,0 +1,17 @@
+import type { HistoryReader } from "./history-reader.js";
+import { type BlameSelection, type BlameState } from "./blame-model.js";
+/** An explicit main-panel file selection owns its pin, worker progress and drain. */
+export declare class BlameController {
+    #private;
+    readonly reader: HistoryReader;
+    readonly feedback: {
+        report(error: unknown): void;
+        recovered(): void;
+    };
+    constructor(reader: HistoryReader, feedback: BlameController["feedback"]);
+    get state(): BlameState;
+    subscribe(listener: (state: BlameState) => void): () => void;
+    open(selection: BlameSelection): Promise<void>;
+    refresh(): Promise<void>;
+    close(): Promise<void>;
+}

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

@@ -0,0 +1,148 @@
+import { HistoryLifetime } from "./history-lifetime.js";
+import { check, prepared } from "./history-selection.js";
+import { sourceLines, blameSizeReason } from "./blame-chunks.js";
+import { validateBlame, } from "./blame-model.js";
+/** An explicit main-panel file selection owns its pin, worker progress and drain. */
+export class BlameController {
+    #state = { status: "loading", busy: false };
+    #listeners = new Set();
+    #generation = 0;
+    #abort = new AbortController();
+    #handle;
+    #closed = false;
+    #closing;
+    #lifetime;
+    reader;
+    feedback;
+    constructor(reader, feedback) {
+        this.reader = reader;
+        this.feedback = feedback;
+        this.#lifetime = new HistoryLifetime(reader);
+    }
+    get state() {
+        return this.#state;
+    }
+    subscribe(listener) {
+        this.#listeners.add(listener);
+        listener(this.#state);
+        return () => {
+            this.#listeners.delete(listener);
+        };
+    }
+    #set(patch) {
+        if (this.#closed)
+            return;
+        this.#state = { ...this.#state, ...patch };
+        for (const listener of this.#listeners)
+            listener(this.#state);
+    }
+    #valid(generation) {
+        return !this.#closed && generation === this.#generation;
+    }
+    open(selection) {
+        if (this.#closed)
+            return Promise.resolve();
+        const generation = ++this.#generation;
+        this.#abort.abort();
+        const abort = (this.#abort = new AbortController());
+        const prior = this.#handle;
+        this.#handle = undefined;
+        this.#set({
+            selection,
+            contents: undefined,
+            progress: undefined,
+            busy: true,
+            status: "loading",
+        });
+        return this.#lifetime.run(async () => {
+            try {
+                if (prior)
+                    await this.#lifetime.closeHandle(prior);
+                if (!this.#valid(generation))
+                    return;
+                if (!this.reader.blame)
+                    throw new Error("Blame is unavailable for this repository reader.");
+                const handle = await this.reader.open(selection.operation);
+                this.#lifetime.handles.add(handle);
+                if (!this.#valid(generation)) {
+                    await this.#lifetime.closeHandle(handle);
+                    return;
+                }
+                this.#handle = handle;
+                const snapshot = await prepared(this.reader, handle, abort.signal);
+                check(snapshot.operation === selection.operation);
+                const cursors = new Set();
+                let continuation = null;
+                let file;
+                for (let page = 0; page < 128 && this.#valid(generation); page++) {
+                    const reply = await this.reader.blame(handle, {
+                        commit: selection.commit,
+                        path: selection.path,
+                        continuation,
+                    });
+                    if (!this.#valid(generation))
+                        return;
+                    const progress = validateBlame(reply, selection);
+                    check(progress.repository === snapshot.repository);
+                    if (!file) {
+                        file = progress.file_id;
+                        const response = await this.reader.read(handle, {
+                            kind: "file_at",
+                            query: { commit: selection.commit, path: selection.path, file },
+                        });
+                        if (!this.#valid(generation))
+                            return;
+                        check(response.kind === "file_at");
+                        const contents = response.data.text;
+                        if (response.data.binary ||
+                            response.data.too_large ||
+                            typeof contents !== "string")
+                            throw new Error("Blame requires a bounded recorded text file.");
+                        const reason = blameSizeReason(contents);
+                        if (reason)
+                            throw new Error(reason);
+                        check(sourceLines(contents).length === progress.line_count);
+                        this.#set({ contents });
+                    }
+                    check(progress.file_id === file);
+                    this.#set({ progress });
+                    if (progress.complete) {
+                        this.#set({ status: "ready" });
+                        this.feedback.recovered();
+                        return;
+                    }
+                    check(progress.continuation && !cursors.has(progress.continuation));
+                    continuation = progress.continuation;
+                    cursors.add(continuation);
+                }
+                if (this.#valid(generation))
+                    throw new Error("Blame exceeded its bounded progress window. Refresh to try again.");
+            }
+            catch (error) {
+                if (this.#valid(generation)) {
+                    this.#set({ status: "failed" });
+                    this.feedback.report(error);
+                }
+            }
+            finally {
+                if (this.#valid(generation))
+                    this.#set({ busy: false });
+            }
+        });
+    }
+    refresh() {
+        return this.#state.selection
+            ? this.open(this.#state.selection)
+            : Promise.resolve();
+    }
+    close() {
+        this.#closed = true;
+        this.#generation++;
+        this.#abort.abort();
+        this.#listeners.clear();
+        return (this.#closing ??= this.#lifetime.drain().catch((error) => {
+            this.#closing = undefined;
+            throw error;
+        }));
+    }
+}

package/dist/repository/controllers/blame-model.d.ts

@@ -0,0 +1,25 @@
+import type { BlamePage } from "@lapismd/jj-history";
+export type { BlameCommit } from "@lapismd/jj-history";
+export type BlameRange = {
+    start: number;
+    end: number;
+    commit_id: string;
+};
+export type BlameProgress = Omit<BlamePage, "line_count" | "ranges"> & {
+    line_count: number;
+    ranges: BlameRange[];
+};
+export type BlameSelection = {
+    operation: string;
+    commit: string;
+    path: string;
+};
+export type BlameState = {
+    selection?: BlameSelection;
+    contents?: string;
+    progress?: BlameProgress;
+    status: "loading" | "ready" | "failed";
+    busy: boolean;
+};
+/** Keep the copied presentation boundary exact even for injected host readers. */
+export declare function validateBlame(page: BlamePage, selection: BlameSelection): BlameProgress;

package/dist/repository/controllers/blame-model.js

@@ -0,0 +1,31 @@
+import { check } from "./history-selection.js";
+/** Keep the copied presentation boundary exact even for injected host readers. */
+export function validateBlame(page, selection) {
+    const line = (value) => {
+        check(typeof value === "bigint" || Number.isSafeInteger(value));
+        check(BigInt(value) >= 0n && BigInt(value) <= 32769n);
+        return Number(value);
+    };
+    const lineCount = line(page.line_count);
+    check(page.operation === selection.operation &&
+        page.commit === selection.commit &&
+        page.path === selection.path &&
+        lineCount <= 32_768 &&
+        page.complete === (page.continuation === null));
+    let end = 1;
+    const ranges = page.ranges.map((range) => ({
+        ...range,
+        start: line(range.start),
+        end: line(range.end),
+    }));
+    for (const range of ranges) {
+        check(Number.isSafeInteger(range.start) &&
+            Number.isSafeInteger(range.end) &&
+            range.start >= end &&
+            range.end > range.start &&
+            range.end <= lineCount + 1 &&
+            page.commits[range.commit_id]?.id === range.commit_id);
+        end = range.end;
+    }
+    return { ...page, line_count: lineCount, ranges };
+}

package/dist/repository/controllers/blame-preferences.d.ts

@@ -0,0 +1,3 @@
+/** A local display preference shared by blame files, independent of the vault. */
+export declare function readBlameWrap(): boolean;
+export declare function saveBlameWrap(wrap: boolean): void;

package/dist/repository/controllers/blame-preferences.js

@@ -0,0 +1,18 @@
+const key = "lapis.desktop.repository.blame.wrap";
+/** A local display preference shared by blame files, independent of the vault. */
+export function readBlameWrap() {
+    try {
+        return localStorage.getItem(key) !== "false";
+    }
+    catch {
+        return true;
+    }
+}
+export function saveBlameWrap(wrap) {
+    try {
+        localStorage.setItem(key, String(wrap));
+    }
+    catch {
+        // Optional browser persistence must not prevent reading recorded source.
+    }
+}

package/dist/repository/controllers/commit-cards.d.ts

@@ -0,0 +1,4 @@
+import type { LocalGraphCommit } from "@lapismd/jj-history";
+import type { TagListItem } from "@lapismd/design-core/shadcn/tag-list";
+export declare function commitCardTags(commit?: LocalGraphCommit): TagListItem[];
+export declare function commitCardSearch(id: string, commit?: LocalGraphCommit): string;