@lapis-notes/history 0.1.4 → 0.2.2

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

@@ -0,0 +1,182 @@
+import { HistoryLifetime } from "./history-lifetime.js";
+import { check, prepared } from "./history-selection.js";
+import { workspaceCommits } from "./operation-metadata.js";
+const initial = () => ({
+    phase: "idle",
+    busy: false,
+    heads: [],
+    commits: [],
+    workspaceCommit: undefined,
+});
+/** Independent file scope; new editor selections fence every delayed response. */
+export class FileHistoryController {
+    #state = initial();
+    #listeners = new Set();
+    #generation = 0;
+    #abort = new AbortController();
+    #handle;
+    #workspace;
+    #closed = false;
+    #pin;
+    #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);
+    }
+    follow(path) {
+        if (path === this.#state.path)
+            return Promise.resolve();
+        this.#pin = undefined;
+        return this.#load(path);
+    }
+    refresh(operation) {
+        if (operation)
+            this.#pin = operation;
+        return this.#load(this.#state.path, operation ?? this.#state.operation);
+    }
+    checkpointChanged(operation) {
+        if (this.#closed ||
+            this.#pin ||
+            !this.#state.path ||
+            this.#state.operation === operation)
+            return Promise.resolve();
+        return this.#load(this.#state.path, operation);
+    }
+    #load(path, operation) {
+        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.#workspace = undefined;
+        this.#set({ ...initial(), path, operation });
+        return this.#run(generation, async () => {
+            if (prior)
+                await this.#lifetime.closeHandle(prior);
+            if (!path || !this.#valid(generation))
+                return;
+            const heads = await this.reader.heads();
+            if (!this.#valid(generation))
+                return;
+            operation ??= heads.heads.length === 1 ? heads.heads[0] : undefined;
+            this.#set({ heads: heads.heads, operation });
+            if (!operation)
+                return;
+            const handle = await this.reader.open(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 === operation);
+            if (!this.#valid(generation))
+                return;
+            const workspaces = await workspaceCommits(this.reader, handle, operation);
+            if (!this.#valid(generation))
+                return;
+            this.#workspace = workspaces.flatMap((commit) => commit.workspaces)[0];
+            if (!this.#workspace)
+                throw new Error("File history requires an existing JJ workspace context.");
+            this.#set({
+                workspaceCommit: workspaces.find((commit) => commit.workspaces.includes(this.#workspace))?.id,
+            });
+            await this.#page(generation, false);
+        });
+    }
+    more() {
+        if (this.#closed || this.#state.busy || !this.#state.next)
+            return Promise.resolve();
+        return this.#run(this.#generation, () => this.#page(this.#generation, true));
+    }
+    #valid(generation) {
+        return !this.#closed && generation === this.#generation;
+    }
+    #run(generation, action) {
+        this.#set({ busy: true, phase: "loading" });
+        return this.#lifetime.run(async () => {
+            try {
+                await action();
+                if (this.#valid(generation)) {
+                    this.#set({ phase: "ready" });
+                    this.feedback.recovered();
+                }
+            }
+            catch (error) {
+                if (this.#valid(generation)) {
+                    this.#set({ phase: "unavailable" });
+                    this.feedback.report(error);
+                }
+            }
+            finally {
+                if (this.#valid(generation))
+                    this.#set({ busy: false });
+            }
+        });
+    }
+    async #page(generation, append) {
+        const { operation, path } = this.#state, handle = this.#handle;
+        if (!handle || !operation || !path)
+            return;
+        const response = await this.reader.read(handle, {
+            kind: "graph",
+            query: [
+                {
+                    graph: "log",
+                    revset: `all() & files(root-file:${JSON.stringify(path)})`,
+                    workspace: this.#workspace,
+                    user_email: "",
+                    at_time_millis: Date.now(),
+                },
+                { limit: 50, after: append ? this.#state.next : null },
+            ],
+        });
+        if (!this.#valid(generation))
+            return;
+        check(response.kind === "graph" &&
+            response.data.operation === operation &&
+            response.data.data.graph === "log");
+        const retained = append ? this.#state.commits : [];
+        const incoming = response.data.data.nodes.map((node) => node.commit);
+        check(!incoming.some((commit) => retained.some((prior) => prior.id === commit.id)));
+        const commits = [...retained, ...incoming].slice(0, 200);
+        this.#set({
+            commits,
+            next: commits.length < 200 ? response.data.next : null,
+        });
+    }
+    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/forge-accounts.d.ts

@@ -0,0 +1,48 @@
+/** Public account identities only. Credentials stay in native custody. */
+export type ForgeAccount = {
+    id: string;
+    api_url: string;
+    login: string;
+    name: string | null;
+    email: string | null;
+    avatar_url: string | null;
+    method: "oauth" | "pat" | "enterprise";
+    available: boolean;
+};
+export type ForgeAuthorization = {
+    session: string;
+    user_code: string;
+    verification_uri: string;
+    interval: number;
+    expires_at: number;
+    state: string;
+};
+export type ForgeInventory = {
+    accounts: ForgeAccount[];
+    oauth_available: boolean;
+    keychain_supported: boolean;
+    authorization: ForgeAuthorization | null;
+};
+export type ForgeCommand = {
+    kind: "begin_oauth";
+} | {
+    kind: "poll_oauth" | "cancel_oauth";
+    session: string;
+} | {
+    kind: "forget";
+    account: string;
+} | {
+    kind: "add_token" | "add_forgejo_token";
+    api_url: string;
+    token: string;
+};
+export interface ForgeService {
+    inventory(): Promise<ForgeInventory>;
+    command(command: ForgeCommand): Promise<ForgeInventory>;
+    openAuthorization(url: string): Promise<void>;
+}
+export type ForgeState = {
+    inventory?: ForgeInventory;
+    busy: boolean;
+    flow: "oauth" | "pat" | "enterprise" | "forgejo" | "";
+};

package/dist/repository/controllers/forge-accounts.js

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

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

@@ -0,0 +1,24 @@
+import type { ForgeService, ForgeState } from "./forge-accounts.js";
+export declare class ForgeController {
+    #private;
+    readonly service: ForgeService;
+    readonly feedback: {
+        report(error: unknown): void;
+        recovered(): void;
+    };
+    constructor(service: ForgeService, feedback: ForgeController["feedback"]);
+    subscribe(listener: (state: ForgeState) => void): () => boolean;
+    subscribeActivity(listener: (state: {
+        busy: boolean;
+        phase: string;
+    }) => void): () => boolean;
+    drained(): Promise<void>;
+    tokenFlow(flow: "pat" | "enterprise" | "forgejo"): void;
+    refresh(): Promise<void>;
+    begin(): Promise<void>;
+    addToken(api_url: string, token: string): Promise<boolean>;
+    forget(account: string): Promise<void>;
+    openAuthorization(): Promise<void>;
+    cancel(): Promise<void>;
+    close(): Promise<void>;
+}

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

@@ -0,0 +1,168 @@
+export class ForgeController {
+    #state = { busy: false, flow: "" };
+    #listeners = new Set();
+    #timer;
+    #epoch = 0;
+    #closed = false;
+    #pending = new Set();
+    #activity = new Set();
+    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);
+    }
+    subscribeActivity(listener) {
+        this.#activity.add(listener);
+        listener({ busy: this.#pending.size > 0, phase: "connecting" });
+        return () => this.#activity.delete(listener);
+    }
+    #track(task) {
+        const tracked = task.finally(() => {
+            this.#pending.delete(tracked);
+            for (const listener of this.#activity)
+                listener({ busy: this.#pending.size > 0, phase: "connecting" });
+        });
+        this.#pending.add(tracked);
+        for (const listener of this.#activity)
+            listener({ busy: true, phase: "connecting" });
+        return tracked;
+    }
+    async drained() {
+        while (this.#pending.size)
+            await Promise.allSettled([...this.#pending]);
+    }
+    #set(patch) {
+        if (this.#closed)
+            return;
+        this.#state = { ...this.#state, ...patch };
+        for (const listener of this.#listeners)
+            listener(this.#state);
+    }
+    tokenFlow(flow) {
+        if (!this.#state.busy && !this.#closed)
+            this.#set({ flow });
+    }
+    async refresh() {
+        if (!this.#closed && !this.#state.busy)
+            await this.#run();
+    }
+    async begin() {
+        if (this.#closed || this.#state.busy)
+            return;
+        this.#set({ flow: "oauth" });
+        await this.#run({ kind: "begin_oauth" });
+    }
+    async addToken(api_url, token) {
+        return this.#run({
+            kind: this.#state.flow === "forgejo" ? "add_forgejo_token" : "add_token",
+            api_url,
+            token,
+        });
+    }
+    async forget(account) {
+        await this.#run({ kind: "forget", account });
+    }
+    #run(command) {
+        if (this.#closed || this.#state.busy)
+            return Promise.resolve(false);
+        const epoch = this.#epoch;
+        this.#set({ busy: true });
+        const task = (async () => {
+            try {
+                const incoming = command
+                    ? await this.service.command(command)
+                    : await this.service.inventory();
+                if (epoch !== this.#epoch || this.#closed) {
+                    if (incoming.authorization?.state === "pending")
+                        await this.service.command({
+                            kind: "cancel_oauth",
+                            session: incoming.authorization.session,
+                        });
+                    return false;
+                }
+                const inventory = command
+                    ? incoming
+                    : {
+                        ...incoming,
+                        authorization: this.#state.inventory?.authorization ?? null,
+                    };
+                this.#set({ inventory });
+                this.feedback.recovered();
+                if (command?.kind === "add_token" ||
+                    command?.kind === "add_forgejo_token" ||
+                    inventory.authorization?.state === "complete")
+                    this.#set({ flow: "" });
+                if (inventory.authorization?.state === "pending")
+                    this.#schedule();
+                else if (inventory.authorization &&
+                    ["denied", "expired", "failed"].includes(inventory.authorization.state))
+                    this.feedback.report(new Error(`GitHub authorization ${inventory.authorization.state}. Start again for a new code.`));
+                return true;
+            }
+            catch (error) {
+                if (epoch === this.#epoch && !this.#closed)
+                    this.feedback.report(error);
+                return false;
+            }
+            finally {
+                if (epoch === this.#epoch)
+                    this.#set({ busy: false });
+            }
+        })();
+        return this.#track(task);
+    }
+    #schedule() {
+        clearTimeout(this.#timer);
+        const auth = this.#state.inventory?.authorization;
+        if (!auth || auth.state !== "pending")
+            return;
+        this.#timer = setTimeout(() => void this.#run({ kind: "poll_oauth", session: auth.session }), Math.max(5, Math.min(60, auth.interval)) * 1000);
+    }
+    async openAuthorization() {
+        const url = this.#state.inventory?.authorization?.verification_uri;
+        if (this.#closed || url !== "https://github.com/login/device")
+            return;
+        try {
+            await this.service.openAuthorization(url);
+        }
+        catch (error) {
+            if (!this.#closed)
+                this.feedback.report(error);
+        }
+    }
+    async cancel() {
+        clearTimeout(this.#timer);
+        this.#epoch++;
+        const session = this.#state.inventory?.authorization?.session;
+        this.#set({
+            flow: "",
+            busy: false,
+            inventory: this.#state.inventory
+                ? { ...this.#state.inventory, authorization: null }
+                : undefined,
+        });
+        if (session)
+            try {
+                await this.#track(this.service.command({ kind: "cancel_oauth", session }));
+            }
+            catch (error) {
+                if (!this.#closed)
+                    this.feedback.report(error);
+            }
+    }
+    async close() {
+        if (this.#closed)
+            return;
+        this.#closed = true;
+        this.#listeners.clear();
+        await this.cancel();
+        // Late responses remain fenced and cancel their private pending grant.
+        // Account network work is installation-owned and cannot hold vault close.
+    }
+}

package/dist/repository/controllers/graph/model.d.ts

@@ -0,0 +1,20 @@
+import type { LocalGraphCommit, LocalGraphOperationNode } from "@lapismd/jj-history";
+/** Presentation-only adaptation of jj-store's commit/operation graph model. */
+export type RepositoryLogRevision = {
+    eventId: string;
+    changeId: string;
+    parents: string[];
+    message: string;
+    reason: "checkpoint" | "merge";
+    author: string;
+    host?: string;
+    millis: number | bigint;
+    tags: string[];
+    conflicted?: boolean;
+};
+export type RepositoryLogDevice = {
+    alias: string;
+    revisionEventId: string;
+};
+export declare function commitRows(commits: LocalGraphCommit[]): RepositoryLogRevision[];
+export declare function operationRows(nodes: LocalGraphOperationNode[]): RepositoryLogRevision[];

package/dist/repository/controllers/graph/model.js

@@ -0,0 +1,33 @@
+export function commitRows(commits) {
+    return commits.map((commit) => ({
+        eventId: commit.id,
+        changeId: commit.change_id,
+        parents: commit.parents,
+        message: commit.description.split("\n")[0] || "No description",
+        reason: commit.parents.length > 1 ? "merge" : "checkpoint",
+        author: commit.author.name,
+        millis: commit.author.timestamp.millis,
+        conflicted: commit.conflicted,
+        tags: [
+            ...(commit.divergent ? ["Divergent"] : []),
+            ...commit.bookmarks.map((bookmark) => `${bookmark.name}${bookmark.remote ? `@${bookmark.remote}` : ""}${bookmark.conflicted ? " (conflicted)" : ""}`),
+            ...commit.workspaces.map((workspace) => workspace === "default" ? "Working copy" : `Working copy · ${workspace}`),
+        ],
+    }));
+}
+export function operationRows(nodes) {
+    return nodes.map((node) => ({
+        eventId: node.id,
+        changeId: "",
+        parents: node.parents,
+        message: node.description || "No description",
+        reason: node.parents.length > 1 ? "merge" : "checkpoint",
+        author: node.user,
+        host: node.host,
+        millis: node.end.millis,
+        tags: [
+            ...(node.is_snapshot ? ["Snapshot"] : []),
+            ...(node.workspace ? [node.workspace] : []),
+        ],
+    }));
+}

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

@@ -0,0 +1,44 @@
+import type { RepositoryLogDevice, RepositoryLogRevision } from "./model.js";
+import * as laneState from "./repository-log-lanes.js";
+export type { RepositoryLogGraphLane } from "./repository-log-lanes.js";
+export declare const REPOSITORY_LOG_ROW_HEIGHT = 76;
+export declare const REPOSITORY_LOG_LANE_WIDTH = 12;
+export declare const REPOSITORY_LOG_NODE_RADIUS = 4;
+export declare const REPOSITORY_LOG_LEFT_PAD = 8;
+export declare const REPOSITORY_LOG_STROKE_WIDTH = 2.5;
+export declare const REPOSITORY_LOG_LANE_COLORS: readonly ["var(--ui-log-lane-1, #2563eb)", "var(--ui-log-lane-2, #16a34a)", "var(--ui-log-lane-3, #d97706)", "var(--ui-log-lane-4, #dc2626)", "var(--ui-log-lane-5, #7c3aed)", "var(--ui-log-lane-6, #0891b2)", "var(--ui-log-lane-7, #db2777)", "var(--ui-log-lane-8, #65a30d)"];
+export type RepositoryLogGraphRow = {
+    revision: RepositoryLogRevision;
+    commitLane: number;
+    lanes: laneState.RepositoryLogGraphLane[];
+    mergeFromLanes: number[];
+    convergingLanes: number[];
+    splitFromLane: number | null;
+    commitStartsLane: boolean;
+    isFirst: boolean;
+    isTip: boolean;
+    deviceAliases: string[];
+    changeIdShort: string;
+    changeIdEncoded: string;
+    commitIdShort: string;
+};
+export declare const REPOSITORY_LOG_ID_PREFIX = 8;
+export declare function encodeJjChangeId(hex: string): string;
+export declare function shortestRepositoryLogPrefix(values: readonly string[], min?: number): Map<string, string>;
+export declare function repositoryLogRowLabel(row: {
+    revision: RepositoryLogRevision;
+    changeIdShort: string;
+    commitIdShort: string;
+}): string;
+export declare function tipRevisionIds(revisions: readonly RepositoryLogRevision[]): string[];
+export declare function repositoryLogLaneX(lane: number): number;
+export declare function repositoryLogLaneStem(row: RepositoryLogGraphRow, lane: number, rowHeight?: number): {
+    y1: number;
+    y2: number;
+};
+export declare function repositoryLogSplitPath(parentX: number, commitX: number, rowHeight?: number): string;
+export declare function repositoryLogMergePath(commitX: number, parentX: number, rowHeight?: number): string;
+export declare function repositoryLogConvergePath(fromX: number, commitX: number, rowHeight?: number): string;
+export declare function repositoryLogContentLeft(row: RepositoryLogGraphRow): number;
+export declare function repositoryLogSvgWidth(rows: RepositoryLogGraphRow[]): number;
+export declare function buildRepositoryLogGraph(revisions: readonly RepositoryLogRevision[], devices?: readonly RepositoryLogDevice[]): RepositoryLogGraphRow[];