import type {

FileSystem,

JsonlSessionMetadata,

LeafEntry,

SessionStorage,

SessionTreeEntry,

} from "../types.js";

import type { FileSystem, JsonlSessionMetadata, SessionTreeEntry } from "../types.js";

import { SessionError, toError } from "../types.js";

import { getFileSystemResultOrThrow } from "./repo-utils.js";

import { uuidv7 } from "./uuid.js";

import { BaseSessionStorage, leafIdAfterEntry } from "./storage-base.js";

type JsonlSessionStorageFileSystem = Pick<

FileSystem,

parentSession?: string;

}

function updateLabelCache(labelsById: Map<string, string>, entry: SessionTreeEntry): void {

if (entry.type !== "label") {

return;

}

const label = entry.label?.trim();

if (label) {

labelsById.set(entry.targetId, label);

} else {

labelsById.delete(entry.targetId);

}

}

function buildLabelsById(entries: SessionTreeEntry[]): Map<string, string> {

const labelsById = new Map<string, string>();

for (const entry of entries) {

updateLabelCache(labelsById, entry);

}

return labelsById;

}

function generateEntryId(byId: { has(id: string): boolean }): string {

for (let i = 0; i < 100; i++) {

const id = uuidv7().slice(0, 8);

if (!byId.has(id)) {

return id;

}

}

return uuidv7();

}

function isRecord(value: unknown): value is Record<string, unknown> {

return typeof value === "object" && value !== null;

}

return parsed as unknown as SessionTreeEntry;

}

function leafIdAfterEntry(entry: SessionTreeEntry): string | null {

return entry.type === "leaf" ? entry.targetId : entry.id;

}

function headerToSessionMetadata(header: SessionHeader, path: string): JsonlSessionMetadata {

return {

id: header.id,

return { header, entries, leafId };

}

export class JsonlSessionStorage implements SessionStorage<JsonlSessionMetadata> {

export class JsonlSessionStorage extends BaseSessionStorage<JsonlSessionMetadata> {

private readonly fs: JsonlSessionStorageFileSystem;

private readonly filePath: string;

private readonly metadata: JsonlSessionMetadata;

private entries: SessionTreeEntry[];

private byId: Map<string, SessionTreeEntry>;

private labelsById: Map<string, string>;

private currentLeafId: string | null;

private constructor(

fs: JsonlSessionStorageFileSystem,

entries: SessionTreeEntry[],

leafId: string | null,

) {

super(headerToSessionMetadata(header, filePath), entries, leafId);

this.fs = fs;

this.filePath = filePath;

this.metadata = headerToSessionMetadata(header, this.filePath);

this.entries = entries;

this.byId = new Map(entries.map((entry) => [entry.id, entry]));

this.labelsById = buildLabelsById(entries);

this.currentLeafId = leafId;

}

static async open(

return new JsonlSessionStorage(fs, filePath, header, [], null);

}

async getMetadata(): Promise<JsonlSessionMetadata> {

return this.metadata;

}

async getLeafId(): Promise<string | null> {

if (this.currentLeafId !== null && !this.byId.has(this.currentLeafId)) {

throw new SessionError("invalid_session", `Entry ${this.currentLeafId} not found`);

}

return this.currentLeafId;

}

async setLeafId(leafId: string | null): Promise<void> {

if (leafId !== null && !this.byId.has(leafId)) {

throw new SessionError("not_found", `Entry ${leafId} not found`);

}

const entry: LeafEntry = {

type: "leaf",

id: generateEntryId(this.byId),

parentId: this.currentLeafId,

timestamp: new Date().toISOString(),

targetId: leafId,

};

override async setLeafId(leafId: string | null): Promise<void> {

const entry = this.createLeafEntry(leafId);

getFileSystemResultOrThrow(

await this.fs.appendFile(this.filePath, `${JSON.stringify(entry)}\n`),

`Failed to append session leaf ${entry.id}`,

);

this.entries.push(entry);

this.byId.set(entry.id, entry);

this.currentLeafId = leafId;

}

async createEntryId(): Promise<string> {

return generateEntryId(this.byId);

this.recordEntry(entry);

}

async appendEntry(entry: SessionTreeEntry): Promise<void> {

override async appendEntry(entry: SessionTreeEntry): Promise<void> {

getFileSystemResultOrThrow(

await this.fs.appendFile(this.filePath, `${JSON.stringify(entry)}\n`),

`Failed to append session entry ${entry.id}`,

);

this.entries.push(entry);

this.byId.set(entry.id, entry);

updateLabelCache(this.labelsById, entry);

this.currentLeafId = leafIdAfterEntry(entry);

}

async getEntry(id: string): Promise<SessionTreeEntry | undefined> {

return this.byId.get(id);

}

async findEntries<TType extends SessionTreeEntry["type"]>(

type: TType,

): Promise<Array<Extract<SessionTreeEntry, { type: TType }>>> {

return this.entries.filter(

(entry): entry is Extract<SessionTreeEntry, { type: TType }> => entry.type === type,

);

}

async getLabel(id: string): Promise<string | undefined> {

return this.labelsById.get(id);

}

async getPathToRoot(leafId: string | null): Promise<SessionTreeEntry[]> {

if (leafId === null) {

return [];

}

const path: SessionTreeEntry[] = [];

let current = this.byId.get(leafId);

if (!current) {

throw new SessionError("not_found", `Entry ${leafId} not found`);

}

while (current) {

path.unshift(current);

if (!current.parentId) {

break;

}

const parent = this.byId.get(current.parentId);

if (!parent) {

throw new SessionError("invalid_session", `Entry ${current.parentId} not found`);

}

current = parent;

}

return path;

}

async getEntries(): Promise<SessionTreeEntry[]> {

return [...this.entries];

this.recordEntry(entry);

}

}