wiki-viewer 1.0.0

package/.next/standalone/src/lib/root-dir.ts

@@ -0,0 +1,35 @@
+import path from "node:path";
+
+// Use globalThis so the value persists across Next.js hot-reloads in dev.
+const g = globalThis as typeof globalThis & { __wikiRootDir?: string };
+
+// Initialise once from env on first import.
+if (!g.__wikiRootDir && process.env.ROOT_DIR) {
+	g.__wikiRootDir = path.resolve(process.env.ROOT_DIR);
+}
+
+export function getRootDir(): string {
+	return g.__wikiRootDir ?? "";
+}
+
+export function isRootDirSet(): boolean {
+	return !!g.__wikiRootDir;
+}
+
+export function setRootDir(dir: string): void {
+	g.__wikiRootDir = path.resolve(dir);
+}
+
+export function clearRootDir(): void {
+	g.__wikiRootDir = undefined;
+}
+
+/** Returns the absolute path for `rel`, or null on traversal / root not set. */
+export function safeRootPath(rel: string): string | null {
+	const root = getRootDir();
+	if (!root) return null;
+	if (!rel || rel === ".") return root;
+	const resolved = path.resolve(root, rel);
+	if (resolved !== root && !resolved.startsWith(root + path.sep)) return null;
+	return resolved;
+}

package/.next/standalone/src/lib/toast.ts

@@ -0,0 +1,9 @@
+import { type ExternalToast, toast } from "sonner";
+
+export function showSuccess(message: string, options?: ExternalToast) {
+	toast.success(message, options);
+}
+
+export function showError(message: string, options?: ExternalToast) {
+	toast.error(message, options);
+}

package/.next/standalone/src/lib/utils.ts

@@ -0,0 +1,6 @@
+import { type ClassValue, clsx } from "clsx";
+import { twMerge } from "tailwind-merge";
+
+export function cn(...inputs: ClassValue[]) {
+	return twMerge(clsx(inputs));
+}

package/.next/standalone/src/lib/wiki-helpers.ts

@@ -0,0 +1,36 @@
+import { stat } from "node:fs/promises";
+import path from "node:path";
+
+/**
+ * Returns true if the directory has a package.json — treated as a runnable node app.
+ * Checked before isAppFolder so package.json wins over index.html.
+ */
+export async function isNodeApp(
+	wikiDir: string,
+	relPath: string,
+): Promise<boolean> {
+	try {
+		const pkgJson = path.join(wikiDir, relPath, "package.json");
+		const info = await stat(pkgJson);
+		return info.isFile();
+	} catch {
+		return false;
+	}
+}
+
+/**
+ * Returns true if `<wikiDir>/<relPath>/index.html` exists and is a regular file.
+ * Used server-side to classify a directory as a self-contained static app folder.
+ */
+export async function isAppFolder(
+	wikiDir: string,
+	relPath: string,
+): Promise<boolean> {
+	try {
+		const indexHtml = path.join(wikiDir, relPath, "index.html");
+		const info = await stat(indexHtml);
+		return info.isFile();
+	} catch {
+		return false;
+	}
+}

package/.next/standalone/src/stores/ai-panel-store.ts

@@ -0,0 +1,23 @@
+"use client";
+import { create } from "zustand";
+
+// Minimal stub. The editor reads open/clearMessages/open from this store.
+// Extend as needed when an AI panel is added to ccmc.
+
+interface AIPanelState {
+	isOpen: boolean;
+	open: () => void;
+	close: () => void;
+	toggle: () => void;
+	clearMessages: () => void;
+}
+
+export const useAIPanelStore = create<AIPanelState>((set) => ({
+	isOpen: false,
+	open: () => set({ isOpen: true }),
+	close: () => set({ isOpen: false }),
+	toggle: () => set((s) => ({ isOpen: !s.isOpen })),
+	clearMessages: () => {
+		/* no-op: no messages in stub */
+	},
+}));

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

@@ -0,0 +1,244 @@
+import { create } from "zustand";
+import type { FrontMatter, SaveStatus } from "@/types";
+
+// 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;
+}
+
+async function fetchPageFromApi(path: string): Promise<PageData> {
+	const res = await fetch(`/api/wiki/content?path=${encodeURIComponent(path)}`);
+	if (!res.ok) {
+		throw new FetchPageError(`Failed to fetch page: ${path}`, res.status);
+	}
+	const data: { content: string } = await res.json();
+	return { path, content: data.content, frontmatter: null };
+}
+
+async function savePageToApi(path: string, content: string): Promise<void> {
+	const res = await fetch("/api/wiki/content", {
+		method: "PUT",
+		headers: { "Content-Type": "application/json" },
+		body: JSON.stringify({ path, content }),
+	});
+	if (!res.ok) {
+		throw new Error("Failed to save page");
+	}
+}
+
+async function createPageInApi(path: string, content = ""): Promise<void> {
+	// ccmc has no dedicated create endpoint; saving empty content creates the file.
+	await savePageToApi(path, content);
+}
+
+const PAGE_CACHE_KEY = "kb-page-cache";
+
+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";
+
+interface EditorState {
+	currentPath: string | null;
+	content: string;
+	frontmatter: FrontMatter | null;
+	saveStatus: SaveStatus;
+	loadStatus: LoadStatus;
+	isDirty: boolean;
+	isLoading: boolean;
+	lastSavedAt: number | null;
+
+	loadPage: (path: string) => Promise<void>;
+	updateContent: (content: string) => void;
+	updateFrontmatter: (updates: Partial<FrontMatter>) => void;
+	save: () => Promise<void>;
+	createMissingPage: (title: string) => Promise<void>;
+	clear: () => void;
+}
+
+let saveTimer: ReturnType<typeof setTimeout> | null = null;
+let statusTimer: ReturnType<typeof setTimeout> | null = null;
+
+export const useEditorStore = create<EditorState>((set, get) => ({
+	currentPath: null,
+	content: "",
+	frontmatter: null,
+	saveStatus: "idle",
+	loadStatus: "idle",
+	isDirty: false,
+	isLoading: false,
+	lastSavedAt: null,
+
+	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: "",
+		});
+
+		// Paint from cache immediately so the editor feels instant.
+		const cached = loadCachedPage(path);
+		if (cached) {
+			set({
+				content: cached.content,
+				frontmatter: cached.frontmatter,
+				isLoading: false,
+				loadStatus: "ok",
+			});
+		}
+
+		try {
+			const page = await fetchPageFromApi(path);
+			// A newer loadPage() call may have superseded us.
+			if (get().currentPath !== path) return;
+			set({
+				content: page.content,
+				frontmatter: page.frontmatter,
+				isLoading: false,
+				loadStatus: "ok",
+			});
+			saveCachedPage({
+				path,
+				content: page.content,
+				frontmatter: page.frontmatter,
+			});
+		} catch (err) {
+			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) => {
+		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 } = get();
+		if (!currentPath || !isDirty) return;
+
+		set({ saveStatus: "saving" });
+		try {
+			await savePageToApi(currentPath, content);
+			set({ saveStatus: "saved", isDirty: false, lastSavedAt: Date.now() });
+			saveCachedPage({
+				path: currentPath,
+				content,
+				frontmatter: get().frontmatter,
+			});
+
+			if (statusTimer) clearTimeout(statusTimer);
+			statusTimer = setTimeout(() => {
+				if (get().saveStatus === "saved") set({ saveStatus: "idle" });
+			}, 2000);
+		} catch {
+			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,
+		});
+	},
+}));

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

@@ -0,0 +1,52 @@
+"use client";
+import { create } from "zustand";
+import type { TreeNode } from "@/types";
+
+// Minimal stub used by folder-index.tsx navigation callbacks.
+// The editor's folder navigation (selectPage, expandPath) is wired here.
+// ccmc doesn't have a global tree sidebar, so these are local no-ops
+// that still satisfy the type contract.
+
+interface TreeState {
+	nodes: TreeNode[];
+	selectedPath: string | null;
+	expandedPaths: Set<string>;
+
+	loadTree: () => Promise<void>;
+	selectPage: (path: string | null) => void;
+	expandPath: (path: string) => void;
+	focusPath: (path: string) => void;
+}
+
+export const useTreeStore = create<TreeState>((set, get) => ({
+	nodes: [],
+	selectedPath: null,
+	expandedPaths: new Set<string>(),
+
+	loadTree: async () => {
+		// No-op in ccmc; the documents page manages its own tree.
+	},
+
+	selectPage: (path: string | null) => {
+		set({ selectedPath: path });
+	},
+
+	expandPath: (path: string) => {
+		const { expandedPaths } = get();
+		if (!expandedPaths.has(path)) {
+			const next = new Set(expandedPaths);
+			next.add(path);
+			set({ expandedPaths: next });
+		}
+	},
+
+	focusPath: (path: string) => {
+		const { expandedPaths } = get();
+		const next = new Set(expandedPaths);
+		const parts = path.split("/");
+		for (let i = 1; i < parts.length; i++) {
+			next.add(parts.slice(0, i).join("/"));
+		}
+		set({ selectedPath: path, expandedPaths: next });
+	},
+}));

package/.next/standalone/src/stores/wiki-slugs-store.ts

@@ -0,0 +1,74 @@
+"use client";
+import { create } from "zustand";
+
+type Dir = "entities" | "concepts" | "comparisons" | "root";
+
+interface SlugBuckets {
+	entities: string[];
+	concepts: string[];
+	comparisons: string[];
+	root: string[];
+}
+
+interface WikiSlugsState {
+	slugs: Set<string>;
+	slugDir: Map<string, Dir>;
+	loadedAt: number | null;
+	loading: boolean;
+	load(): Promise<void>;
+	has(slug: string): boolean;
+	getDir(slug: string): Dir | null;
+	invalidate(): void;
+}
+
+export type { Dir as WikiSlugDir };
+
+export const useWikiSlugsStore = create<WikiSlugsState>((set, get) => ({
+	slugs: new Set<string>(),
+	slugDir: new Map<string, Dir>(),
+	loadedAt: null,
+	loading: false,
+
+	load: async () => {
+		const { loadedAt, loading } = get();
+		if (loading) return;
+		if (loadedAt !== null && Date.now() - loadedAt < 10_000) return;
+
+		set({ loading: true });
+		try {
+			const res = await fetch("/api/wiki/slugs");
+			if (!res.ok) throw new Error("Failed to fetch wiki slugs");
+			const buckets = (await res.json()) as SlugBuckets;
+
+			const slugs = new Set<string>();
+			const slugDir = new Map<string, Dir>();
+
+			const dirs: Dir[] = ["entities", "concepts", "comparisons", "root"];
+			for (const dir of dirs) {
+				for (const slug of buckets[dir]) {
+					slugs.add(slug);
+					// First bucket wins if a slug appears in multiple (shouldn't happen)
+					if (!slugDir.has(slug)) {
+						slugDir.set(slug, dir);
+					}
+				}
+			}
+
+			set({ slugs, slugDir, loadedAt: Date.now(), loading: false });
+		} catch {
+			set({ loading: false });
+		}
+	},
+
+	has(slug: string): boolean {
+		return get().slugs.has(slug);
+	},
+
+	getDir(slug: string): Dir | null {
+		return get().slugDir.get(slug) ?? null;
+	},
+
+	invalidate(): void {
+		set({ loadedAt: null });
+	},
+}));

package/.next/standalone/src/types/index.ts

@@ -0,0 +1,47 @@
+// Editor types used by the editor, stores, and viewer components.
+
+export interface GoogleFrontmatter {
+	kind?: "sheets" | "slides" | "docs" | "forms" | "drive";
+	url: string;
+	embedUrl?: string;
+}
+
+export interface FrontMatter {
+	title: string;
+	created: string;
+	modified: string;
+	tags: string[];
+	icon?: string;
+	order?: number;
+	dir?: "ltr" | "rtl";
+	google?: GoogleFrontmatter;
+}
+
+export interface TreeNode {
+	name: string;
+	path: string;
+	type:
+		| "file"
+		| "directory"
+		| "cabinet"
+		| "website"
+		| "app"
+		| "pdf"
+		| "csv"
+		| "code"
+		| "image"
+		| "video"
+		| "audio"
+		| "mermaid"
+		| "docx"
+		| "xlsx"
+		| "pptx"
+		| "notebook"
+		| "unknown";
+	hasRepo?: boolean;
+	isLinked?: boolean;
+	frontmatter?: Partial<FrontMatter>;
+	children?: TreeNode[];
+}
+
+export type SaveStatus = "idle" | "saving" | "saved" | "error";