@lapis-notes/history 0.1.2 → 0.2.0

package/dist/repository/controllers/history-index-controller.d.ts

@@ -0,0 +1,22 @@
+import type { HistoryIndexStatus, IndexedHistoryService } from "./indexed-search.js";
+export type HistoryIndexState = {
+    busy: boolean;
+    phase: string;
+    status?: HistoryIndexStatus;
+};
+/** Observe cached vault-owned progress; no renderer request schedules a batch. */
+export declare class HistoryIndexController {
+    #private;
+    readonly service: IndexedHistoryService;
+    readonly feedback: {
+        report(error: unknown): void;
+        recovered(): void;
+    };
+    constructor(service: IndexedHistoryService, feedback: {
+        report(error: unknown): void;
+        recovered(): void;
+    });
+    subscribe(listener: (state: HistoryIndexState) => void): () => void;
+    start(): void;
+    close(): Promise<void>;
+}

package/dist/repository/controllers/history-index-controller.js

@@ -0,0 +1,77 @@
+/** Observe cached vault-owned progress; no renderer request schedules a batch. */
+export class HistoryIndexController {
+    service;
+    feedback;
+    #closed = false;
+    #started = false;
+    #job;
+    #timer;
+    #listeners = new Set();
+    #state = { busy: false, phase: "ready" };
+    #failure = "";
+    constructor(service, feedback) {
+        this.service = service;
+        this.feedback = feedback;
+    }
+    subscribe(listener) {
+        this.#listeners.add(listener);
+        listener(this.#state);
+        return () => {
+            this.#listeners.delete(listener);
+        };
+    }
+    #set(state) {
+        if (this.#closed)
+            return;
+        this.#state = state;
+        for (const listener of this.#listeners)
+            listener(state);
+    }
+    start() {
+        if (this.#closed || this.#started)
+            return;
+        this.#started = true;
+        this.#set({ busy: true, phase: "indexing" });
+        this.#observe(true);
+    }
+    #observe(initial = false) {
+        if (this.#closed || this.#job)
+            return;
+        this.#job = this.#read(initial).finally(() => {
+            this.#job = undefined;
+            if (!this.#closed)
+                this.#timer = setTimeout(() => this.#observe(), 1000);
+        });
+    }
+    async #read(initial) {
+        try {
+            const status = await (initial
+                ? this.service.start()
+                : this.service.status());
+            if (this.#closed)
+                return;
+            this.#set({
+                busy: !status.complete,
+                phase: status.complete ? "ready" : "indexing",
+                status,
+            });
+            this.#failure = "";
+            this.feedback.recovered();
+        }
+        catch (error) {
+            if (this.#closed)
+                return;
+            const message = String(error);
+            if (message !== this.#failure)
+                this.feedback.report(error);
+            this.#failure = message;
+            this.#set({ ...this.#state, busy: false, phase: "paused" });
+        }
+    }
+    async close() {
+        this.#closed = true;
+        clearTimeout(this.#timer);
+        await this.#job;
+        this.#listeners.clear();
+    }
+}

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

@@ -0,0 +1,13 @@
+import type { Handle } from "@lapismd/jj-history";
+import type { HistoryReader } from "./history-reader.js";
+/** Ephemeral handles remain owned until either close or full host release confirms. */
+export declare class HistoryLifetime {
+    readonly pending: Set<Promise<unknown>>;
+    readonly handles: Set<string>;
+    readonly closing: Map<string, Promise<void>>;
+    readonly reader: HistoryReader;
+    constructor(reader: HistoryReader);
+    run(action: () => Promise<void>): Promise<void>;
+    closeHandle(handle: Handle): Promise<void>;
+    drain(): Promise<void>;
+}

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

@@ -0,0 +1,40 @@
+/** Ephemeral handles remain owned until either close or full host release confirms. */
+export class HistoryLifetime {
+    pending = new Set();
+    handles = new Set();
+    closing = new Map();
+    reader;
+    constructor(reader) {
+        this.reader = reader;
+    }
+    run(action) {
+        const job = action();
+        this.pending.add(job);
+        void job.finally(() => this.pending.delete(job)).catch(() => { });
+        return job;
+    }
+    closeHandle(handle) {
+        const retained = this.closing.get(handle);
+        if (retained)
+            return retained;
+        const job = this.reader.close(handle).then(() => {
+            this.handles.delete(handle);
+        });
+        this.closing.set(handle, job);
+        void job.finally(() => this.closing.delete(handle)).catch(() => { });
+        return job;
+    }
+    async drain() {
+        const known = new Set(this.handles);
+        // Native close cancels pending reads before draining their workers.
+        const closing = Promise.allSettled([...known].map((handle) => this.closeHandle(handle)));
+        while (this.pending.size)
+            await Promise.allSettled([...this.pending]);
+        const late = await Promise.allSettled([...this.handles]
+            .filter((handle) => !known.has(handle))
+            .map((handle) => this.closeHandle(handle)));
+        const failures = [...(await closing), ...late].flatMap((result) => result.status === "rejected" ? [result.reason] : []);
+        if (failures.length)
+            throw new AggregateError(failures, "Repository history cleanup failed");
+    }
+}

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

@@ -0,0 +1,22 @@
+import type { HistoryClient } from "@lapismd/jj-history";
+/** Transport-independent reader supplied by the host, never by persisted state. */
+export type HistoryReader = Pick<HistoryClient, "heads" | "open" | "status" | "read" | "close"> & Partial<Pick<HistoryClient, "blame">>;
+export type RepositoryLeaveMode = "close" | "reload";
+export interface RepositoryServices {
+    aiHistory?: import("./ai-history.js").AiHistoryService;
+    adoption?: import("./adoption.js").AdoptionService;
+    sources?: () => Promise<{
+        original: boolean;
+    }>;
+    original?: HistoryReader;
+    storage?: import("./storage.js").StorageService;
+    search?: import("./search.js").HistorySearchService;
+    sync?: import("./sync.js").SyncService;
+    remote?: import("./remote.js").RemoteService;
+    forges?: import("./forge-accounts.js").ForgeService;
+    restore?: import("./restore.js").RestoreService;
+    backup?: import("./backup.js").BackupService;
+    reader: HistoryReader;
+    workingCopy?: () => Promise<import("./working-copy-status.js").WorkingCopyStatus>;
+    close(mode: RepositoryLeaveMode): Promise<void>;
+}

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

@@ -0,0 +1 @@
+export {};

package/dist/repository/controllers/history-search-expression.d.ts

@@ -0,0 +1,9 @@
+import type { SearchQueryExpression } from "@lapis-notes/api";
+import type { HistoryExpression } from "./indexed-search.js";
+/** Lower the shared parser AST; never interpret unsupported syntax as plain text. */
+export declare function historyExpression(node: SearchQueryExpression | null, field?: string | null): HistoryExpression;
+export declare function historyTerms(node: SearchQueryExpression | null): string[];
+export declare function historyRanges(text: string, terms: string[]): {
+    start: number;
+    end: number;
+}[];

package/dist/repository/controllers/history-search-expression.js

@@ -0,0 +1,86 @@
+/** Lower the shared parser AST; never interpret unsupported syntax as plain text. */
+export function historyExpression(node, field = null) {
+    if (!node)
+        throw new Error("Enter a history search query");
+    switch (node.type) {
+        case "group":
+            return historyExpression(node.expression, field);
+        case "and":
+        case "or":
+            return {
+                type: node.type,
+                clauses: node.clauses.map((child) => historyExpression(child, field)),
+            };
+        case "not":
+            return { type: "not", operand: historyExpression(node.operand, field) };
+        case "field": {
+            if (![
+                "file",
+                "path",
+                "content",
+                "author",
+                "before",
+                "after",
+                "commit",
+            ].includes(node.name))
+                throw new Error(`History does not support ${node.name} filters`);
+            return historyExpression(node.value, node.name);
+        }
+        case "literal": {
+            if ((node.kind !== "word" && node.kind !== "phrase") || !node.value)
+                throw new Error("History supports text and phrase values");
+            let value = node.value;
+            if (field === "after" || field === "before") {
+                const date = /^\d{4}-\d{2}-\d{2}$/.test(value)
+                    ? `${value}T00:00:00Z`
+                    : value;
+                const millis = Date.parse(date);
+                if (!Number.isSafeInteger(millis))
+                    throw new Error("Use an ISO date for history date filters");
+                // A date-only 'before' includes the entire specified UTC day.
+                value = String(millis +
+                    (field === "before" && /^\d{4}-\d{2}-\d{2}$/.test(node.value)
+                        ? 86_399_999
+                        : 0));
+            }
+            return { type: "term", field, value };
+        }
+        default:
+            throw new Error("This query predicate is unavailable for history");
+    }
+}
+export function historyTerms(node) {
+    if (!node)
+        return [];
+    switch (node.type) {
+        case "literal":
+            return node.value && ["word", "phrase"].includes(node.kind)
+                ? [node.value]
+                : [];
+        case "group":
+            return historyTerms(node.expression);
+        case "and":
+        case "or":
+            return node.clauses.flatMap(historyTerms);
+        case "field":
+            return ["content", "file", "path"].includes(node.name)
+                ? historyTerms(node.value)
+                : [];
+        default:
+            return [];
+    }
+}
+export function historyRanges(text, terms) {
+    const ranges = [];
+    for (const term of terms) {
+        const haystack = text.toLowerCase(), needle = term.toLowerCase();
+        if (!needle)
+            continue;
+        let start = haystack.indexOf(needle);
+        while (start >= 0 && ranges.length < 100) {
+            ranges.push({ start, end: start + needle.length });
+            start = haystack.indexOf(needle, start + needle.length);
+        }
+    }
+    return ranges.sort((a, b) => a.start - b.start);
+}

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

@@ -0,0 +1,5 @@
+import type { Handle, LocalCodeSnapshot } from "@lapismd/jj-history";
+import type { HistoryReader } from "./history-reader.js";
+export declare function check(condition: unknown): asserts condition;
+export declare function pause(signal: AbortSignal): Promise<void>;
+export declare function prepared(reader: HistoryReader, handle: Handle, signal: AbortSignal, wait?: typeof pause): Promise<LocalCodeSnapshot>;

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

@@ -0,0 +1,32 @@
+export function check(condition) {
+    if (!condition)
+        throw new Error("Repository history returned a different selection");
+}
+export function pause(signal) {
+    if (signal.aborted)
+        return Promise.reject(signal.reason);
+    return new Promise((resolve, reject) => {
+        const cancel = () => {
+            clearTimeout(timer);
+            reject(signal.reason);
+        };
+        const timer = setTimeout(() => {
+            signal.removeEventListener("abort", cancel);
+            resolve();
+        }, 50);
+        signal.addEventListener("abort", cancel, { once: true });
+    });
+}
+export async function prepared(reader, handle, signal, wait = pause) {
+    for (let attempt = 0; attempt < 100; attempt++) {
+        signal.throwIfAborted();
+        const status = await reader.status(handle);
+        signal.throwIfAborted();
+        if (status.state === "ready")
+            return status.data;
+        if (status.state === "failed")
+            throw new Error("Repository history preparation failed");
+        await wait(signal);
+    }
+    throw new Error("Repository history preparation did not finish in time");
+}

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

@@ -0,0 +1,10 @@
+export type HistorySource = "backup" | "original";
+export declare function historySource(state: Record<string, unknown>): HistorySource;
+export interface HistorySourcePicker {
+    selected: HistorySource;
+    load(): Promise<{
+        original: boolean;
+    }>;
+    select(source: HistorySource): void;
+    report(error: unknown): void;
+}

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

@@ -0,0 +1,7 @@
+export function historySource(state) {
+    if (state.source === undefined || state.source === "backup")
+        return "backup";
+    if (state.source === "original")
+        return "original";
+    throw new Error("Invalid repository history source");
+}

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

@@ -0,0 +1,34 @@
+import type { LocalConflictDescriptor, LocalCodeSnapshot, LocalGraphCommit, LocalCodeObjectKey, LocalFileDiffChange } from "@lapismd/jj-history";
+export interface HistoryState {
+    phase: "idle" | "loading" | "ready" | "unavailable";
+    busy: boolean;
+    workspace: string | null;
+    conflicts: LocalConflictDescriptor[];
+    conflictsReady: boolean;
+    heads: string[];
+    headsReady: boolean;
+    operation?: string;
+    snapshot?: LocalCodeSnapshot;
+    commits: LocalGraphCommit[];
+    commitsReady: boolean;
+    next?: LocalCodeObjectKey | null;
+    revision?: LocalGraphCommit;
+    base?: string;
+    parentCommits: LocalGraphCommit[];
+    paths: LocalFileDiffChange[];
+    pathsReady: boolean;
+    nextPath?: string | null;
+    path?: string;
+    diff?: LocalFileDiffChange;
+}
+export declare const initialHistoryState: () => HistoryState;
+export declare function revisionLabel(commit: LocalGraphCommit): string;
+export declare function timestampLabel(millis: number | bigint): string;
+export declare function diffText(change: LocalFileDiffChange): {
+    oldText: string;
+    newText: string;
+} | {
+    unavailable: string;
+};
+/** Clears the selected revision and every dependent comparison value. */
+export declare function resetHistoryComparison(): Partial<HistoryState>;

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

@@ -0,0 +1,55 @@
+export const initialHistoryState = () => ({
+    phase: "idle",
+    busy: false,
+    workspace: null,
+    conflicts: [],
+    conflictsReady: false,
+    heads: [],
+    headsReady: false,
+    commits: [],
+    commitsReady: false,
+    parentCommits: [],
+    paths: [],
+    pathsReady: false,
+    operation: undefined,
+    snapshot: undefined,
+    next: undefined,
+    revision: undefined,
+    base: undefined,
+    nextPath: undefined,
+    path: undefined,
+    diff: undefined,
+});
+export function revisionLabel(commit) {
+    return commit.description.split("\n")[0] || "No description";
+}
+export function timestampLabel(millis) {
+    const value = BigInt(millis);
+    return value >= -8640000000000000n && value <= 8640000000000000n
+        ? new Date(Number(value)).toLocaleString()
+        : `${value} milliseconds since epoch`;
+}
+export function diffText(change) {
+    if (change.content.status === "unavailable")
+        return { unavailable: change.content.reason.replaceAll("_", " ") };
+    const oldText = change.content.hunks.map((hunk) => hunk.before).join("");
+    const newText = change.content.hunks.map((hunk) => hunk.after).join("");
+    if (new TextEncoder().encode(oldText + newText).length > 1024 * 1024)
+        return { unavailable: "The text exceeds the preview limit" };
+    return { oldText, newText };
+}
+/** Clears the selected revision and every dependent comparison value. */
+export function resetHistoryComparison() {
+    return {
+        conflicts: [],
+        conflictsReady: false,
+        revision: undefined,
+        parentCommits: [],
+        base: undefined,
+        paths: [],
+        pathsReady: false,
+        nextPath: null,
+        path: undefined,
+        diff: undefined,
+    };
+}

package/dist/repository/controllers/indexed-search-validation.d.ts

@@ -0,0 +1,4 @@
+import type { HistoryIndexStatus, IndexedHistoryPage, HistoryMatchContext } from "./indexed-search.js";
+export declare function indexStatus(value: unknown): HistoryIndexStatus;
+export declare function indexedPage(value: unknown): IndexedHistoryPage;
+export declare function matchContext(value: unknown): HistoryMatchContext;

package/dist/repository/controllers/indexed-search-validation.js

@@ -0,0 +1,64 @@
+import { searchPage } from "./search-page.js";
+const object = (value) => !!value && typeof value === "object";
+const count = (value) => Number.isSafeInteger(value) && Number(value) >= 0;
+const commit = (value) => typeof value === "string" && /^[0-9a-f]{40}$/.test(value);
+export function indexStatus(value) {
+    if (!object(value) ||
+        !count(value.generation) ||
+        !count(value.indexed) ||
+        !count(value.omitted) ||
+        typeof value.complete !== "boolean")
+        throw new Error("Invalid history index status");
+    return value;
+}
+export function indexedPage(value) {
+    if (!object(value) ||
+        !Array.isArray(value.hits) ||
+        value.hits.length > 100 ||
+        typeof value.reset !== "boolean" ||
+        (value.next != null &&
+            (typeof value.next !== "string" || value.next.length > 512)))
+        throw new Error("Invalid indexed history response");
+    indexStatus(value.status);
+    for (const hit of value.hits) {
+        if (!object(hit) || !object(hit.record))
+            throw new Error("Invalid indexed history hit");
+        const record = hit.record;
+        searchPage({
+            hits: [
+                {
+                    revision: record.revision,
+                    path: record.path,
+                    excerpt: hit.excerpt,
+                    line: hit.line,
+                },
+            ],
+            checkpoints: 0,
+            unindexed: 0,
+        });
+        if (!Array.isArray(record.parents) ||
+            record.parents.length > 1024 ||
+            !record.parents.every(commit) ||
+            typeof record.deleted !== "boolean" ||
+            typeof record.unavailable !== "boolean" ||
+            (record.previous != null && !commit(record.previous)) ||
+            (record.content_id != null &&
+                (typeof record.content_id !== "string" ||
+                    !/^[0-9a-f]{40,128}$/.test(record.content_id))) ||
+            (hit.line != null && (!count(hit.line) || Number(hit.line) < 1)))
+            throw new Error("Invalid indexed version reference");
+    }
+    return value;
+}
+export function matchContext(value) {
+    if (!object(value) ||
+        typeof value.text !== "string" ||
+        value.text.length > 32768 ||
+        !count(value.start) ||
+        !count(value.end) ||
+        Number(value.end) < Number(value.start) ||
+        typeof value.before !== "boolean" ||
+        typeof value.after !== "boolean")
+        throw new Error("Invalid saved match context");
+    return value;
+}

package/dist/repository/controllers/indexed-search.d.ts

@@ -0,0 +1,11 @@
+import type { HistoryIndexCommand, HistoryIndexQuery, HistoryIndexProgress, HistoryIndexPage, HistoryIndexContext } from "@lapis-notes/api/native-history-index";
+export type { HistoryExpression, HistoryIndexProgress as HistoryIndexStatus, HistoryIndexHit as IndexedHistoryHit, HistoryIndexPage as IndexedHistoryPage, HistoryIndexContext as HistoryMatchContext, } from "@lapis-notes/api/native-history-index";
+/** Native owners schedule all indexing; renderers observe and query saved data. */
+export interface IndexedHistoryService {
+    start(): Promise<HistoryIndexProgress>;
+    status(): Promise<HistoryIndexProgress>;
+    query(request: HistoryIndexQuery): Promise<HistoryIndexPage>;
+    context(request: Omit<Extract<HistoryIndexCommand, {
+        kind: "context";
+    }>, "kind">): Promise<HistoryIndexContext>;
+}

package/dist/repository/controllers/indexed-search.js

@@ -0,0 +1 @@
+export {};

package/dist/repository/controllers/log-canvas.d.ts

@@ -0,0 +1,2 @@
+/** jj-store log/diff column geometry. The public root owns pane-responsive mode. */
+export declare function createLogCanvas(): import("@lapismd/design-core/shadcn/column-canvas").ColumnCanvasController;

package/dist/repository/controllers/log-canvas.js

@@ -0,0 +1,25 @@
+import { createColumnCanvasController } from "@lapismd/design-core/shadcn/column-canvas";
+/** jj-store log/diff column geometry. The public root owns pane-responsive mode. */
+export function createLogCanvas() {
+    return createColumnCanvasController({
+        columns: {
+            revisions: {
+                defaultWidth: 480,
+                minWidth: 360,
+                maxWidth: 720,
+                collapsible: true,
+                resizable: true,
+            },
+            diff: {
+                defaultWidth: 560,
+                minWidth: 360,
+                maxWidth: 980,
+                pathLevel: 1,
+                closeable: true,
+                closed: true,
+                openOnSelect: false,
+                resizable: true,
+            },
+        },
+    });
+}

package/dist/repository/controllers/native-indexed-search.d.ts

@@ -0,0 +1,4 @@
+import type { NativeHistoryIndex } from "@lapis-notes/api/native-history-index";
+import type { IndexedHistoryService } from "./indexed-search.js";
+/** Hosts retain admission and lifetime; this adapter never steps or stops work. */
+export declare function nativeIndexedHistory(port: NativeHistoryIndex): IndexedHistoryService;

package/dist/repository/controllers/native-indexed-search.js

@@ -0,0 +1,10 @@
+import { indexStatus, indexedPage, matchContext, } from "./indexed-search-validation.js";
+/** Hosts retain admission and lifetime; this adapter never steps or stops work. */
+export function nativeIndexedHistory(port) {
+    return {
+        start: async () => indexStatus(await port.call({ kind: "start" })),
+        status: async () => indexStatus(await port.call({ kind: "status" })),
+        query: async (search) => indexedPage(await port.call({ kind: "query", search })),
+        context: async (request) => matchContext(await port.call({ kind: "context", ...request })),
+    };
+}

package/dist/repository/controllers/open-history-revision.d.ts

@@ -0,0 +1,3 @@
+import type { HistoryController } from "./history-controller.js";
+/** Exact native commit reads can open retained search results beyond graph paging. */
+export declare function openHistoryRevision(controller: HistoryController, id: string): Promise<void>;

package/dist/repository/controllers/open-history-revision.js

@@ -0,0 +1,8 @@
+/** Exact native commit reads can open retained search results beyond graph paging. */
+export async function openHistoryRevision(controller, id) {
+    const commit = controller.state.commits.find((item) => item.id === id);
+    if (commit)
+        await controller.selectRevision(commit);
+    else
+        await controller.openRevision(id);
+}

package/dist/repository/controllers/operation-command.d.ts

@@ -0,0 +1,2 @@
+/** Display-only normalization of JJ's recorded transaction argument format. */
+export declare function operationCommandLabel(recorded: string): string;

package/dist/repository/controllers/operation-command.js

@@ -0,0 +1,55 @@
+/** Display-only normalization of JJ's recorded transaction argument format. */
+export function operationCommandLabel(recorded) {
+    if (recorded.length > 65_536 || /[\r\n\t]/u.test(recorded))
+        return recorded;
+    const words = [];
+    let i = 0;
+    while (i < recorded.length) {
+        while (recorded[i] === " ")
+            i++;
+        if (i === recorded.length)
+            break;
+        let word = "";
+        if (recorded[i] === "'") {
+            i++;
+            let closed = false;
+            while (i < recorded.length) {
+                if (recorded[i] === "\\" && recorded[i + 1] === "'") {
+                    word += "'";
+                    i += 2;
+                }
+                else if (recorded[i] === "'") {
+                    i++;
+                    closed = true;
+                    break;
+                }
+                else
+                    word += recorded[i++];
+            }
+            if (!closed || (i < recorded.length && recorded[i] !== " "))
+                return recorded;
+        }
+        else {
+            const start = i;
+            while (i < recorded.length && recorded[i] !== " ")
+                i++;
+            word = recorded.slice(start, i);
+            if (!/^[A-Za-z0-9,./:@_-]+$/u.test(word))
+                return recorded;
+        }
+        words.push(word);
+    }
+    if (words[0] !== "jj")
+        return recorded;
+    return words
+        .map((word) => {
+        if (/^[A-Za-z0-9,./:@_-]+$/u.test(word))
+            return word;
+        if (!word.includes("'"))
+            return `'${word}'`;
+        if (!/["$`\\]/u.test(word))
+            return `"${word}"`;
+        return `'${word.replaceAll("'", "'\\''")}'`;
+    })
+        .join(" ");
+}