wiki-viewer 1.14.1 → 2.0.0

package/.next/standalone/src/stores/editor-store.ts

@@ -1,439 +0,0 @@
-import { create } from "zustand";
-import type { FrontMatter, SaveStatus } from "@/types";
-import { wsFetch } from "@/lib/workspace-client";
-
-// Adapter around ccmc's /api/wiki/content endpoints.
-// The API returns { content: string } and accepts { path, content }.
-// We model frontmatter as null since ccmc doesn't expose it from the API.
-
-export class FetchPageError extends Error {
-	constructor(
-		message: string,
-		public readonly status: number,
-	) {
-		super(message);
-		this.name = "FetchPageError";
-	}
-}
-
-interface PageData {
-	path: string;
-	content: string;
-	frontmatter: FrontMatter | null;
-	revision: number | null;
-}
-
-async function fetchPageFromApi(path: string, signal?: AbortSignal): Promise<PageData> {
-	const res = await wsFetch(`/api/wiki/content?path=${encodeURIComponent(path)}`, { signal });
-	if (!res.ok) {
-		throw new FetchPageError(`Failed to fetch page: ${path}`, res.status);
-	}
-	const data: { content: string } = await res.json();
-	const revHeader = res.headers.get("X-Wiki-Revision");
-	const revision = revHeader !== null ? Number(revHeader) : null;
-	return { path, content: data.content, frontmatter: null, revision };
-}
-
-interface SaveResult {
-	revision: number | null;
-}
-
-/** Error thrown when the server reports a stale revision (409). */
-export class StaleRevisionError extends Error {
-	constructor(
-		public readonly currentRevision: number,
-		public readonly serverContent: string,
-	) {
-		super("File was modified externally. Reloaded with latest content.");
-		this.name = "StaleRevisionError";
-	}
-}
-
-async function savePageToApi(
-	path: string,
-	content: string,
-	baseRevision: number | null,
-): Promise<SaveResult> {
-	const body: Record<string, unknown> = { path, content };
-	if (baseRevision !== null) body.baseRevision = baseRevision;
-	const res = await wsFetch("/api/wiki/content", {
-		method: "PUT",
-		headers: { "Content-Type": "application/json" },
-		body: JSON.stringify(body),
-	});
-	if (res.status === 409) {
-		// Server has a newer revision. Fetch current content and surface the conflict.
-		const conflictData = (await res.json()) as { currentRevision?: number };
-		const freshRes = await wsFetch(`/api/wiki/content?path=${encodeURIComponent(path)}`);
-		const freshContent = freshRes.ok
-			? ((await freshRes.json()) as { content: string }).content
-			: content;
-		throw new StaleRevisionError(conflictData.currentRevision ?? 0, freshContent);
-	}
-	if (!res.ok) {
-		throw new Error("Failed to save page");
-	}
-	const data = (await res.json()) as { revision?: number };
-	return { revision: data.revision ?? null };
-}
-
-async function createPageInApi(path: string, content = ""): Promise<void> {
-	// ccmc has no dedicated create endpoint; saving empty content creates the file.
-	await savePageToApi(path, content, null);
-}
-
-const PAGE_CACHE_KEY = "kb-page-cache";
-
-// In-memory LRU of recently fetched pages. The localStorage cache holds only the
-// single most-recent page; this lets back-and-forth navigation and hover-prefetch
-// paint instantly without a round-trip. Bounded so it can't grow without limit.
-const MEM_CACHE_MAX = 30;
-const pageMemCache = new Map<string, PageData>();
-// Dedups concurrent fetches for the same path (hover-prefetch + click race).
-const inflightPages = new Map<string, Promise<PageData>>();
-
-function memCacheGet(path: string): PageData | null {
-	const hit = pageMemCache.get(path);
-	if (!hit) return null;
-	// Refresh LRU recency.
-	pageMemCache.delete(path);
-	pageMemCache.set(path, hit);
-	return hit;
-}
-
-function memCacheSet(page: PageData): void {
-	pageMemCache.delete(page.path);
-	pageMemCache.set(page.path, page);
-	if (pageMemCache.size > MEM_CACHE_MAX) {
-		const oldest = pageMemCache.keys().next().value;
-		if (oldest !== undefined) pageMemCache.delete(oldest);
-	}
-}
-
-/**
- * Fetch a page into the in-memory cache ahead of an actual open (e.g. on tree
- * hover). Deduped via inflightPages so a hover followed by a click reuses the
- * same request. Best-effort: failures are swallowed.
- */
-export function prefetchPage(path: string): void {
-	if (pageMemCache.has(path) || inflightPages.has(path)) return;
-	const p = fetchPageFromApi(path)
-		.then((page) => {
-			memCacheSet(page);
-			return page;
-		})
-		.finally(() => {
-			inflightPages.delete(path);
-		});
-	inflightPages.set(path, p);
-	// Swallow rejections so an unawaited prefetch never throws unhandled.
-	p.catch(() => {});
-}
-
-interface CachedPage {
-	path: string;
-	content: string;
-	frontmatter: FrontMatter | null;
-}
-
-function loadCachedPage(path: string): CachedPage | null {
-	if (typeof window === "undefined") return null;
-	try {
-		const raw = localStorage.getItem(PAGE_CACHE_KEY);
-		if (!raw) return null;
-		const parsed = JSON.parse(raw) as CachedPage;
-		if (parsed.path !== path) return null;
-		return parsed;
-	} catch {
-		return null;
-	}
-}
-
-function saveCachedPage(page: CachedPage) {
-	if (typeof window === "undefined") return;
-	try {
-		localStorage.setItem(PAGE_CACHE_KEY, JSON.stringify(page));
-	} catch {
-		// quota errors are non-fatal
-	}
-}
-
-export type LoadStatus = "idle" | "loading" | "ok" | "missing" | "error";
-
-/**
- * Editor interaction mode.
- * - "editing": human edits write directly to the file (full-file PUT).
- * - "suggesting": human block edits are captured as suggestions (block ops,
- *   by: "human") and the editor block reverts to the snapshot. The file is
- *   not changed until a suggestion is accepted.
- */
-export type EditMode = "editing" | "suggesting";
-
-interface EditorState {
-	currentPath: string | null;
-	content: string;
-	frontmatter: FrontMatter | null;
-	saveStatus: SaveStatus;
-	loadStatus: LoadStatus;
-	isDirty: boolean;
-	isLoading: boolean;
-	lastSavedAt: number | null;
-	/** Last confirmed revision from the server. null until first save/sync. */
-	currentRevision: number | null;
-	/** Current interaction mode. Persisted in localStorage. */
-	editMode: EditMode;
-
-	loadPage: (path: string) => Promise<void>;
-	updateContent: (content: string) => void;
-	updateFrontmatter: (updates: Partial<FrontMatter>) => void;
-	save: () => Promise<void>;
-	createMissingPage: (title: string) => Promise<void>;
-	clear: () => void;
-	/** Sync the known revision from an external source (e.g. proof-store snapshot). */
-	syncRevision: (revision: number) => void;
-	/** Switch interaction mode (editing | suggesting). */
-	setEditMode: (mode: EditMode) => void;
-}
-
-const EDIT_MODE_KEY = "kb-edit-mode";
-
-function loadEditMode(): EditMode {
-	if (typeof window === "undefined") return "editing";
-	return localStorage.getItem(EDIT_MODE_KEY) === "suggesting"
-		? "suggesting"
-		: "editing";
-}
-
-let saveTimer: ReturnType<typeof setTimeout> | null = null;
-let statusTimer: ReturnType<typeof setTimeout> | null = null;
-// Aborts the in-flight content fetch when a newer loadPage() supersedes it, so
-// rapid navigation doesn't pile up requests behind the browser connection limit.
-let loadAbort: AbortController | null = null;
-
-export const useEditorStore = create<EditorState>((set, get) => ({
-	currentPath: null,
-	content: "",
-	frontmatter: null,
-	saveStatus: "idle",
-	loadStatus: "idle",
-	isDirty: false,
-	isLoading: false,
-	lastSavedAt: null,
-	currentRevision: null,
-	editMode: loadEditMode(),
-
-	setEditMode: (mode: EditMode) => {
-		if (typeof window !== "undefined") {
-			localStorage.setItem(EDIT_MODE_KEY, mode);
-		}
-		set({ editMode: mode });
-	},
-
-	loadPage: async (path: string) => {
-		const currentState = get();
-		// If we're switching to a different page, save any pending changes first.
-		if (
-			currentState.isDirty &&
-			currentState.currentPath &&
-			currentState.currentPath !== path
-		) {
-			await get().save();
-		}
-
-		set({
-			currentPath: path,
-			isLoading: true,
-			loadStatus: "loading",
-			isDirty: false,
-			content: "",
-			currentRevision: null,
-		});
-
-		// Paint from cache immediately so the editor feels instant. In-memory LRU
-		// (incl. hover-prefetched pages) wins over the single-slot localStorage cache.
-		const mem = memCacheGet(path);
-		const cached = mem ?? loadCachedPage(path);
-		if (cached) {
-			set({
-				content: cached.content,
-				frontmatter: cached.frontmatter,
-				isLoading: false,
-				loadStatus: "ok",
-				...(mem ? { currentRevision: mem.revision } : {}),
-			});
-		}
-
-		// If a hover-prefetch for this path is already in flight, ride it instead of
-		// firing a second request.
-		const pending = inflightPages.get(path);
-		if (pending) {
-			try {
-				const page = await pending;
-				if (get().currentPath !== path) return;
-				set({
-					content: page.content,
-					frontmatter: page.frontmatter,
-					isLoading: false,
-					loadStatus: "ok",
-					currentRevision: page.revision,
-				});
-				saveCachedPage({ path, content: page.content, frontmatter: page.frontmatter });
-				return;
-			} catch {
-				// fall through to a fresh fetch below
-			}
-		}
-
-		// Abort any prior in-flight content fetch — rapid navigation otherwise
-		// queues N fetches behind the browser's ~6-connection-per-host limit.
-		loadAbort?.abort();
-		const ctrl = new AbortController();
-		loadAbort = ctrl;
-
-		try {
-			const page = await fetchPageFromApi(path, ctrl.signal);
-			memCacheSet(page);
-			// A newer loadPage() call may have superseded us.
-			if (get().currentPath !== path) return;
-			set({
-				content: page.content,
-				frontmatter: page.frontmatter,
-				isLoading: false,
-				loadStatus: "ok",
-				currentRevision: page.revision,
-			});
-			saveCachedPage({
-				path,
-				content: page.content,
-				frontmatter: page.frontmatter,
-			});
-		} catch (err) {
-			// Superseded fetch was aborted — newer navigation owns the state now.
-			if (err instanceof DOMException && err.name === "AbortError") return;
-			if (get().currentPath !== path) return;
-			if (err instanceof FetchPageError && err.status === 404) {
-				set({ isLoading: false, loadStatus: "missing", content: "" });
-			} else {
-				// Keep cached content visible; mark as error.
-				set({ isLoading: false, loadStatus: "error" });
-			}
-		}
-	},
-
-	updateContent: (content: string) => {
-		// In suggesting mode, human edits never write the file directly. They are
-		// captured as suggestions (block ops) and the editor reverts. Skip the
-		// dirty flag + autosave entirely so no full-file PUT is scheduled.
-		if (get().editMode === "suggesting") {
-			set({ content });
-			return;
-		}
-		set({ content, isDirty: true });
-
-		// Auto-save after 500 ms of inactivity.
-		if (saveTimer) clearTimeout(saveTimer);
-		saveTimer = setTimeout(() => {
-			get().save();
-		}, 500);
-	},
-
-	updateFrontmatter: (updates: Partial<FrontMatter>) => {
-		const current = get().frontmatter;
-		set({
-			frontmatter: { ...current, ...updates } as FrontMatter,
-			isDirty: true,
-		});
-		if (saveTimer) clearTimeout(saveTimer);
-		saveTimer = setTimeout(() => {
-			get().save();
-		}, 500);
-	},
-
-	save: async () => {
-		const { currentPath, content, isDirty, currentRevision, editMode } = get();
-		if (!currentPath || !isDirty) return;
-		// Suggesting mode must never write the file via full-file PUT.
-		if (editMode === "suggesting") return;
-
-		set({ saveStatus: "saving" });
-		try {
-			const result = await savePageToApi(currentPath, content, currentRevision);
-			set({
-				saveStatus: "saved",
-				isDirty: false,
-				lastSavedAt: Date.now(),
-				currentRevision: result.revision ?? currentRevision,
-			});
-			saveCachedPage({
-				path: currentPath,
-				content,
-				frontmatter: get().frontmatter,
-			});
-			memCacheSet({
-				path: currentPath,
-				content,
-				frontmatter: get().frontmatter,
-				revision: result.revision ?? currentRevision,
-			});
-
-			if (statusTimer) clearTimeout(statusTimer);
-			statusTimer = setTimeout(() => {
-				if (get().saveStatus === "saved") set({ saveStatus: "idle" });
-			}, 2000);
-		} catch (err) {
-			if (err instanceof StaleRevisionError) {
-				// Server has a newer revision: reload editor with fresh content.
-				set({
-					content: err.serverContent,
-					isDirty: false,
-					saveStatus: "error",
-					currentRevision: err.currentRevision,
-				});
-				saveCachedPage({
-					path: currentPath,
-					content: err.serverContent,
-					frontmatter: get().frontmatter,
-				});
-			} else {
-				set({ saveStatus: "error" });
-			}
-		}
-	},
-
-	createMissingPage: async (title: string) => {
-		const { currentPath } = get();
-		if (!currentPath) return;
-		const initialContent = `# ${title}\n\n`;
-		try {
-			await createPageInApi(`${currentPath}/index.md`, initialContent);
-			set({ content: initialContent, isDirty: false, loadStatus: "ok" });
-			saveCachedPage({
-				path: currentPath,
-				content: initialContent,
-				frontmatter: null,
-			});
-		} catch {
-			// silently ignore — user can retry
-		}
-	},
-
-	clear: () => {
-		if (saveTimer) clearTimeout(saveTimer);
-		if (statusTimer) clearTimeout(statusTimer);
-		set({
-			currentPath: null,
-			content: "",
-			frontmatter: null,
-			saveStatus: "idle",
-			loadStatus: "idle",
-			isDirty: false,
-			isLoading: false,
-			lastSavedAt: null,
-			currentRevision: null,
-		});
-	},
-
-	syncRevision: (revision: number) => {
-		set({ currentRevision: revision });
-	},
-}));

package/.next/standalone/src/stores/pin-store.ts

@@ -1,56 +0,0 @@
-"use client";
-import { create } from "zustand";
-
-export interface PinnedEntry {
-	path: string;
-	name: string;
-	type?: "file" | "app" | "node-app";
-}
-
-interface PinState {
-	pins: PinnedEntry[];
-	loadForWorkspace: (workspaceId: string | null | undefined) => void;
-	toggle: (entry: PinnedEntry, workspaceId: string | null | undefined) => void;
-	isPinned: (path: string) => boolean;
-}
-
-function storageKey(ws: string | null | undefined): string {
-	return ws ? `wiki-pinned-files-${ws}` : "wiki-pinned-files";
-}
-
-function readStorage(ws: string | null | undefined): PinnedEntry[] {
-	if (typeof window === "undefined") return [];
-	try {
-		const raw = localStorage.getItem(storageKey(ws));
-		return raw ? (JSON.parse(raw) as PinnedEntry[]) : [];
-	} catch {
-		return [];
-	}
-}
-
-function writeStorage(ws: string | null | undefined, items: PinnedEntry[]): void {
-	if (typeof window === "undefined") return;
-	localStorage.setItem(storageKey(ws), JSON.stringify(items));
-}
-
-export const usePinStore = create<PinState>((set, get) => ({
-	pins: [],
-
-	loadForWorkspace: (ws) => {
-		set({ pins: readStorage(ws) });
-	},
-
-	toggle: (entry, ws) => {
-		const current = readStorage(ws);
-		const exists = current.some((p) => p.path === entry.path);
-		const next = exists
-			? current.filter((p) => p.path !== entry.path)
-			: [...current, entry];
-		writeStorage(ws, next);
-		set({ pins: next });
-	},
-
-	isPinned: (path) => {
-		return get().pins.some((p) => p.path === path);
-	},
-}));

package/.next/standalone/src/stores/proof-store.ts

@@ -1,124 +0,0 @@
-import { create } from "zustand";
-import { authHeaders } from "@/lib/proof/client-auth";
-import { wsFetch } from "@/lib/workspace-client";
-import { useEditorStore } from "@/stores/editor-store";
-import type { Sidecar, ProofEvent, Block, Snapshot } from "@/lib/proof/types";
-
-interface PathEntry {
-	sidecar: Sidecar | null;
-	snapshotRevision: number;
-	lastEventId: number;
-	/** Ordered block list from latest GET snapshot. Used to resolve ref→position in editor. */
-	snapshotBlocks: Block[];
-}
-
-interface ProofState {
-	byPath: Record<string, PathEntry>;
-	loadSidecar(path: string): Promise<void>;
-	/** Fetch GET /api/agent/files/<path> to get ordered block list for ref positioning. */
-	loadSnapshot(path: string): Promise<void>;
-	pollEvents(path: string): Promise<void>;
-	applyEvent(path: string, e: ProofEvent): void;
-	reset(path: string): void;
-}
-
-function defaultEntry(): PathEntry {
-	return { sidecar: null, snapshotRevision: 0, lastEventId: 0, snapshotBlocks: [] };
-}
-
-export const useProofStore = create<ProofState>((set, get) => ({
-	byPath: {},
-
-	loadSidecar: async (path: string) => {
-		const encoded = encodeURIComponent(path).replace(/%2F/g, "/");
-		try {
-			const res = await wsFetch(`/api/agent/sidecar/${encoded}`, {
-				headers: authHeaders(),
-			});
-			if (!res.ok) return;
-			const sidecar = (await res.json()) as Sidecar;
-			set((s) => ({
-				byPath: {
-					...s.byPath,
-					[path]: {
-						...(s.byPath[path] ?? defaultEntry()),
-						sidecar,
-						snapshotRevision: sidecar.revision,
-						lastEventId: sidecar.nextEventId - 1,
-					},
-				},
-			}));
-		} catch {
-			// network error — leave stale
-		}
-	},
-
-	loadSnapshot: async (path: string) => {
-		const encoded = encodeURIComponent(path).replace(/%2F/g, "/");
-		try {
-			const res = await wsFetch(`/api/agent/files/${encoded}`, {
-				headers: authHeaders(),
-			});
-			if (!res.ok) return;
-			const snap = (await res.json()) as Snapshot;
-			set((s) => ({
-				byPath: {
-					...s.byPath,
-					[path]: {
-						...(s.byPath[path] ?? defaultEntry()),
-						snapshotBlocks: snap.blocks,
-						snapshotRevision: snap.revision,
-					},
-				},
-			}));
-			// Sync revision into editor-store so saves send correct baseRevision.
-			const editorState = useEditorStore.getState();
-			if (editorState.currentPath === path) {
-				editorState.syncRevision(snap.revision);
-			}
-		} catch {
-			// network error — leave stale
-		}
-	},
-
-	pollEvents: async (path: string) => {
-		const entry = get().byPath[path] ?? defaultEntry();
-		const encoded = encodeURIComponent(path).replace(/%2F/g, "/");
-		try {
-			const res = await wsFetch(
-				`/api/agent/events/${encoded}?after=${entry.lastEventId}`,
-				{ headers: authHeaders() },
-			);
-			if (!res.ok) return;
-			const data = (await res.json()) as { events: ProofEvent[]; lastEventId: number };
-			for (const e of data.events) {
-				get().applyEvent(path, e);
-			}
-		} catch {
-			// network error — leave stale
-		}
-	},
-
-	applyEvent: (path: string, e: ProofEvent) => {
-		set((s) => {
-			const prev = s.byPath[path] ?? defaultEntry();
-			return {
-				byPath: {
-					...s.byPath,
-					[path]: {
-						...prev,
-						lastEventId: Math.max(prev.lastEventId, e.id),
-					},
-				},
-			};
-		});
-	},
-
-	reset: (path: string) => {
-		set((s) => {
-			const next = { ...s.byPath };
-			delete next[path];
-			return { byPath: next };
-		});
-	},
-}));

package/.next/standalone/src/stores/recent-store.ts

@@ -1,51 +0,0 @@
-"use client";
-import { create } from "zustand";
-
-export interface RecentEntry {
-	path: string;
-	name: string;
-	type?: "file" | "app" | "node-app";
-}
-
-interface RecentState {
-	recents: RecentEntry[];
-	loadForWorkspace: (workspaceId: string | null | undefined) => void;
-	push: (entry: RecentEntry, workspaceId: string | null | undefined) => void;
-}
-
-const MAX_RECENTS = 15;
-
-function storageKey(ws: string | null | undefined): string {
-	return ws ? `wiki-recent-files-${ws}` : "wiki-recent-files";
-}
-
-function readStorage(ws: string | null | undefined): RecentEntry[] {
-	if (typeof window === "undefined") return [];
-	try {
-		const raw = localStorage.getItem(storageKey(ws));
-		return raw ? (JSON.parse(raw) as RecentEntry[]) : [];
-	} catch {
-		return [];
-	}
-}
-
-function writeStorage(ws: string | null | undefined, items: RecentEntry[]): void {
-	if (typeof window === "undefined") return;
-	localStorage.setItem(storageKey(ws), JSON.stringify(items));
-}
-
-export const useRecentStore = create<RecentState>((set) => ({
-	recents: [],
-
-	loadForWorkspace: (ws) => {
-		set({ recents: readStorage(ws) });
-	},
-
-	push: (entry, ws) => {
-		const current = readStorage(ws);
-		const deduped = current.filter((r) => r.path !== entry.path);
-		const next = [entry, ...deduped].slice(0, MAX_RECENTS);
-		writeStorage(ws, next);
-		set({ recents: next });
-	},
-}));