wiki-viewer 1.14.1 → 1.14.2

package/.next/standalone/src/lib/proof/block-refs.ts

@@ -1,133 +0,0 @@
-import { createHash } from "node:crypto";
-import type { RootContent } from "mdast";
-import type { Block, Sidecar } from "./types";
-import { blockToMarkdown, blockType } from "./blocks";
-
-function sha256hex(input: string): string {
-	return createHash("sha256").update(input, "utf8").digest("hex");
-}
-
-function textHash(markdown: string): string {
-	return sha256hex(markdown).slice(0, 12);
-}
-
-function mintRef(markdown: string, usedRefs: Set<string>, position: number): string {
-	const base = "b" + sha256hex(markdown).slice(0, 6);
-	if (!usedRefs.has(base)) return base;
-	// Collision: try position suffix
-	const withPos = `${base}_${position}`;
-	if (!usedRefs.has(withPos)) return withPos;
-	// Fallback: increment counter
-	let i = 0;
-	while (usedRefs.has(`${base}_${i}`)) i++;
-	return `${base}_${i}`;
-}
-
-/**
- * Assign Block refs to a list of parsed mdast nodes.
- * If a sidecar is provided, reuse existing refs for matching content hashes.
- * Returns Block[] with stable refs and a new refMap.
- */
-export function assignRefs(
-	nodes: RootContent[],
-	sidecar: Sidecar | null,
-): { blocks: Block[]; newRefMap: Record<string, { textHash: string; lastSeenAt: string }> } {
-	const now = new Date().toISOString();
-	const usedRefs = new Set<string>();
-	const newRefMap: Record<string, { textHash: string; lastSeenAt: string }> = {};
-
-	// Build a reverse map: textHash -> ref from existing sidecar
-	const hashToRef = new Map<string, string>();
-	if (sidecar) {
-		for (const [ref, entry] of Object.entries(sidecar.refMap)) {
-			// Only map each hash once (first wins, since refs may have been aliased)
-			if (!hashToRef.has(entry.textHash)) {
-				hashToRef.set(entry.textHash, ref);
-			}
-		}
-	}
-
-	const blocks: Block[] = nodes.map((node, i) => {
-		const md = blockToMarkdown(node);
-		const hash = textHash(md);
-		const { type, level, lang } = blockType(node);
-
-		let ref: string;
-		const existingRef = hashToRef.get(hash);
-		if (existingRef && !usedRefs.has(existingRef)) {
-			ref = existingRef;
-		} else {
-			ref = mintRef(md, usedRefs, i);
-		}
-
-		usedRefs.add(ref);
-		newRefMap[ref] = { textHash: hash, lastSeenAt: now };
-
-		const block: Block = { ref, type, markdown: md };
-		if (level !== undefined) block.level = level;
-		if (lang !== undefined) block.lang = lang;
-		return block;
-	});
-
-	return { blocks, newRefMap };
-}
-
-/**
- * Resolve a ref against current block refs, falling back to aliases.
- */
-export function resolveRef(
-	sidecar: Sidecar,
-	ref: string,
-	currentRefs: Set<string>,
-): string | null {
-	if (currentRefs.has(ref)) return ref;
-	const aliased = sidecar.refAliases[ref];
-	if (aliased && currentRefs.has(aliased)) return aliased;
-	return null;
-}
-
-/**
- * After applying ops: compute new refMap and collect aliases for changed blocks.
- * oldRefMap: refMap before ops. newBlocks: blocks after ops.
- * Returns { newRefMap, refAliases } — aliases map old ref -> new ref for any block
- * that changed identity this mutation. Aliases are ONE-generation only.
- */
-export function computeRefDelta(
-	oldRefMap: Record<string, { textHash: string; lastSeenAt: string }>,
-	oldHashToRef: Map<string, string>,
-	newBlocks: Block[],
-): {
-	newRefMap: Record<string, { textHash: string; lastSeenAt: string }>;
-	refAliases: Record<string, string>;
-} {
-	const now = new Date().toISOString();
-	const newRefMap: Record<string, { textHash: string; lastSeenAt: string }> = {};
-	const refAliases: Record<string, string> = {};
-
-	for (const block of newBlocks) {
-		const hash = textHash(block.markdown);
-		newRefMap[block.ref] = { textHash: hash, lastSeenAt: now };
-
-		// If this block's hash previously mapped to a different ref, record alias
-		const oldRef = oldHashToRef.get(hash);
-		if (oldRef && oldRef !== block.ref) {
-			refAliases[oldRef] = block.ref;
-		}
-	}
-
-	// For any old ref that's no longer present (was replaced/deleted), try to alias
-	// it if we can identify which new block replaced it by position or hash.
-	for (const [oldRef, entry] of Object.entries(oldRefMap)) {
-		if (!newRefMap[oldRef] && !refAliases[oldRef]) {
-			// Old ref gone, no content match found. Check if new block with same hash exists
-			const match = newBlocks.find((b) => b.ref !== oldRef && textHash(b.markdown) === entry.textHash);
-			if (match) {
-				refAliases[oldRef] = match.ref;
-			}
-		}
-	}
-
-	return { newRefMap, refAliases };
-}
-
-export { textHash };

package/.next/standalone/src/lib/proof/blocks.ts

@@ -1,73 +0,0 @@
-import { unified } from "unified";
-import remarkParse from "remark-parse";
-import remarkGfm from "remark-gfm";
-import remarkStringify from "remark-stringify";
-import type { Root, RootContent } from "mdast";
-import type { BlockType } from "./types";
-
-const PARSER = unified().use(remarkParse).use(remarkGfm);
-const STRINGIFY = unified()
-	.use(remarkStringify, {
-		bullet: "-",
-		fence: "`",
-		fences: true,
-		listItemIndent: "one",
-		rule: "-",
-		emphasis: "*",
-		strong: "*",
-	})
-	.use(remarkGfm);
-
-export function parseBlocks(markdown: string): RootContent[] {
-	const tree = PARSER.parse(markdown) as Root;
-	return tree.children;
-}
-
-export function blockToMarkdown(node: RootContent): string {
-	const tree: Root = { type: "root", children: [node] };
-	return (STRINGIFY.stringify(tree) as string).replace(/\n+$/, "");
-}
-
-export function blocksToMarkdown(nodes: RootContent[]): string {
-	if (nodes.length === 0) return "";
-	const tree: Root = { type: "root", children: nodes };
-	return (STRINGIFY.stringify(tree) as string).replace(/\n+$/, "") + "\n";
-}
-
-export function blockType(node: RootContent): {
-	type: BlockType;
-	level?: number;
-	lang?: string;
-} {
-	switch (node.type) {
-		case "heading":
-			return { type: "heading", level: (node as unknown as { depth: number }).depth };
-		case "paragraph":
-			return { type: "paragraph" };
-		case "list": {
-			const n = node as unknown as { ordered: boolean; children: Array<{ checked: boolean | null | undefined }> };
-			if (
-				n.children?.some(
-					(li) => li.checked !== null && li.checked !== undefined,
-				)
-			)
-				return { type: "taskList" };
-			return { type: n.ordered ? "orderedList" : "bulletList" };
-		}
-		case "blockquote":
-			return { type: "blockquote" };
-		case "code":
-			return {
-				type: "codeBlock",
-				lang: (node as unknown as { lang: string | null }).lang ?? undefined,
-			};
-		case "table":
-			return { type: "table" };
-		case "thematicBreak":
-			return { type: "hr" };
-		case "html":
-			return { type: "html" };
-		default:
-			return { type: "paragraph" }; // fallback
-	}
-}

package/.next/standalone/src/lib/proof/client-auth.ts

@@ -1,23 +0,0 @@
-/**
- * Browser-side auth for same-origin UI requests.
- *
- * Authentication is now handled by the owner cookie (wv_owner) set via
- * /api/owner/init. Same-origin fetch automatically attaches cookies, so no
- * explicit Authorization header is needed from the browser UI.
- *
- * All fetch calls from the browser must use credentials: "same-origin" (the
- * default) or credentials: "include".
- */
-
-/** @deprecated No longer returns a token. Owner cookie is used instead. */
-export function getAgentToken(): string | null {
-	return null;
-}
-
-/**
- * Returns empty object — authentication is via owner cookie automatically.
- * Kept for backwards-compat with call sites.
- */
-export function authHeaders(): HeadersInit {
-	return {};
-}

package/.next/standalone/src/lib/proof/collab-state.ts

@@ -1,81 +0,0 @@
-/**
- * Collab-state computation for §3.5 Working mode vs Collaborating mode.
- *
- * Returns:
- *   state     — "active" | "tracked" | "untracked" | "not-markdown"
- *   revision  — X-Collab-Revision (sidecar.revision + leaseGeneration(path))
- *   snapshotUrl — Tier-2 snapshot URL (null for non-markdown)
- *
- * Revision formula:
- *   revision = (sidecar?.revision ?? 0) + leaseGeneration(relPath)
- *
- *   sidecar.revision bumps on every collab write (block-ops, comment, suggestion).
- *   leaseGeneration bumps on every lease open/close.
- *   Together they form a monotonically-non-decreasing integer that changes
- *   whenever collab state could change.  A raw PUT that supplies
- *   If-Collab-Match: <n> is only safe when n equals the revision computed
- *   atomically inside the write mutex — otherwise 409 COLLAB_ACTIVE.
- *
- * active = has artifacts (pendingSuggestions > 0 OR unresolvedComments > 0
- *          OR blockProvenance entries > 0) OR has a current human edit lease.
- */
-
-import { readSidecar } from "./sidecar";
-import { hasActiveLease, leaseGeneration } from "./lease";
-
-function isMarkdownPath(p: string): boolean {
-	return p.endsWith(".md") || p.endsWith(".markdown");
-}
-
-export type CollabState = "active" | "tracked" | "untracked" | "not-markdown";
-
-export interface CollabStateResult {
-	state: CollabState;
-	/** sidecar.revision + leaseGeneration(relPath) */
-	revision: number;
-	/** /api/agent/files/<relPath> — null for not-markdown */
-	snapshotUrl: string | null;
-}
-
-export async function computeCollabState(
-	rootDir: string,
-	relPath: string,
-): Promise<CollabStateResult> {
-	if (!isMarkdownPath(relPath)) {
-		return { state: "not-markdown", revision: 0, snapshotUrl: null };
-	}
-
-	const snapshotUrl = `/api/agent/files/${relPath}`;
-
-	// Compute revision components
-	// ns = rootDir: workspace-namespaces lease keys so two workspaces sharing
-	// the same relPath never collide in the lease store.
-	const sidecar = await readSidecar(rootDir, relPath);
-	const gen = leaseGeneration(rootDir, relPath);
-	const sidecarRevision = sidecar?.revision ?? 0;
-	const revision = sidecarRevision + gen;
-
-	// Lease check — do after reading sidecar to keep gen stable within this call
-	const leaseActive = hasActiveLease(rootDir, relPath);
-
-	if (!sidecar && !leaseActive) {
-		return { state: "untracked", revision, snapshotUrl };
-	}
-
-	if (leaseActive) {
-		return { state: "active", revision, snapshotUrl };
-	}
-
-	// Has sidecar, no lease — inspect artifacts
-	const pendingSuggestions = sidecar!.suggestions.filter(
-		(s) => s.status === "pending" && !s.stale,
-	).length;
-	const unresolvedComments = sidecar!.comments.filter((c) => !c.resolved).length;
-	const proofSpanCount = Object.keys(sidecar!.blockProvenance ?? {}).length;
-
-	if (pendingSuggestions > 0 || unresolvedComments > 0 || proofSpanCount > 0) {
-		return { state: "active", revision, snapshotUrl };
-	}
-
-	return { state: "tracked", revision, snapshotUrl };
-}

package/.next/standalone/src/lib/proof/event-bus.ts

@@ -1,47 +0,0 @@
-import type { ProofEvent, Sidecar } from "./types";
-
-/**
- * Append one or more events to a working sidecar (in-memory mutation).
- * Assigns monotonic IDs from sidecar.nextEventId.
- */
-export function emitEvents(
-	sidecar: Sidecar,
-	partials: Array<Omit<ProofEvent, "id">>,
-): ProofEvent[] {
-	const emitted: ProofEvent[] = [];
-	for (const partial of partials) {
-		const ev = { ...partial, id: sidecar.nextEventId++ } as ProofEvent;
-		sidecar.events.push(ev);
-		emitted.push(ev);
-	}
-	return emitted;
-}
-
-/**
- * Poll events after a given ID, up to limit.
- */
-export function pollEvents(
-	sidecar: Sidecar,
-	afterId: number,
-	limit: number,
-): ProofEvent[] {
-	return sidecar.events.filter((e) => e.id > afterId).slice(0, limit);
-}
-
-/**
- * Trim sidecar events to stay under TRIM_SIZE, preserving events newer than
- * the oldest lastAck cursor to avoid stranding agents.
- */
-export function trimEvents(sidecar: Sidecar, trimSize: number): void {
-	if (sidecar.events.length <= trimSize) return;
-
-	const ackValues = Object.values(sidecar.lastAck);
-	const oldestAck = ackValues.length > 0 ? Math.min(...ackValues) : Infinity;
-
-	// Events to keep: either within trimSize from the end, OR above the oldest ack
-	const keepFrom = sidecar.events.length - trimSize;
-	const trimmedEvents = sidecar.events.filter(
-		(e, i) => i >= keepFrom || e.id > oldestAck,
-	);
-	sidecar.events = trimmedEvents;
-}

package/.next/standalone/src/lib/proof/file-lock.ts

@@ -1,43 +0,0 @@
-// Workspacing note (Phase B): the lockKey must be workspace-unique. Callers
-// should prefix lockKey with rootDir (or wsId): `${rootDir}\0${relPath}`.
-// The cross-process sentinel hash then differs per workspace automatically.
-// Phase B call sites will make this change when route threading is done.
-
-/**
- * Cross-process file locking via proper-lockfile.
- *
- * Uses a sentinel file in ~/.wiki-viewer/.locks/ keyed by a hash of the lock
- * key so the actual data file need not exist before locking.
- */
-import { createHash } from "node:crypto";
-import { mkdir, writeFile } from "node:fs/promises";
-import os from "node:os";
-import path from "node:path";
-import lockfile from "proper-lockfile";
-
-function locksDir(): string {
-	const home = process.env.HOME ?? os.homedir();
-	return path.join(home, ".wiki-viewer", ".locks");
-}
-
-function sentinelPath(lockKey: string): string {
-	const hash = createHash("sha256").update(lockKey, "utf8").digest("hex").slice(0, 32);
-	return path.join(locksDir(), hash);
-}
-
-export async function withFileLock<T>(lockKey: string, fn: () => Promise<T>): Promise<T> {
-	const dir = locksDir();
-	await mkdir(dir, { recursive: true });
-	const sentinel = sentinelPath(lockKey);
-	// Create sentinel if absent (flag "a" = append/create, never truncate)
-	await writeFile(sentinel, "", { flag: "a" });
-
-	const release = await lockfile.lock(sentinel, {
-		retries: { retries: 10, factor: 1.5, minTimeout: 50, maxTimeout: 2_000 },
-	});
-	try {
-		return await fn();
-	} finally {
-		await release();
-	}
-}

package/.next/standalone/src/lib/proof/glob.ts

@@ -1,51 +0,0 @@
-/**
- * Minimal glob matcher.
- *
- * Supported patterns:
- *   **   — any sequence of characters including path separators
- *   *    — any sequence of characters except path separators (/)
- *   ?    — single character that is not /
- *   Literal characters — matched verbatim (case-sensitive)
- *
- * Patterns are anchored to the full string (implicit ^ and $).
- */
-export function matchGlob(pattern: string, filePath: string): boolean {
-	const regex = globToRegex(pattern);
-	return regex.test(filePath);
-}
-
-function globToRegex(pattern: string): RegExp {
-	let regStr = "^";
-	let i = 0;
-	while (i < pattern.length) {
-		if (pattern[i] === "*" && pattern[i + 1] === "*") {
-			// ** — match anything including slashes
-			regStr += ".*";
-			i += 2;
-			// Skip a trailing slash after ** to avoid double-matching: **/foo matches foo too
-			if (pattern[i] === "/") {
-				regStr += "(?:.+/)?";
-				i++;
-				// roll back the .* so we match just /**/ properly
-				// Actually: keep simple — .* already handles it
-			}
-		} else if (pattern[i] === "*") {
-			// * — match non-slash characters
-			regStr += "[^/]*";
-			i++;
-		} else if (pattern[i] === "?") {
-			regStr += "[^/]";
-			i++;
-		} else {
-			// Escape regex special chars
-			regStr += escapeRegex(pattern[i]!);
-			i++;
-		}
-	}
-	regStr += "$";
-	return new RegExp(regStr);
-}
-
-function escapeRegex(c: string): string {
-	return c.replace(/[.+^${}()|[\]\\]/g, "\\$&");
-}

package/.next/standalone/src/lib/proof/idempotency.ts

@@ -1,37 +0,0 @@
-// Workspacing note (Phase B): the idempotency key must be prefixed with wsId
-// (or rootDir) at the call site to prevent cross-workspace collisions:
-// e.g. key = `${rootDir}\0${idempotencyHeader}`. Phase B call sites will
-// make this change when route threading is done.
-
-// Tiny in-memory LRU. Lives for process lifetime. Acceptable: idempotency
-// guards retries within seconds, not days.
-const MAX = 1000;
-const TTL_MS = 5 * 60 * 1000;
-
-interface Entry {
-	payloadHash: string;
-	status: number;
-	body: string;
-	expiresAt: number;
-}
-
-const store = new Map<string, Entry>();
-
-export const idempotency = {
-	get(key: string): Entry | null {
-		const e = store.get(key);
-		if (!e) return null;
-		if (e.expiresAt < Date.now()) {
-			store.delete(key);
-			return null;
-		}
-		return e;
-	},
-	set(key: string, value: Omit<Entry, "expiresAt">): void {
-		if (store.size >= MAX) {
-			const first = store.keys().next().value;
-			if (first !== undefined) store.delete(first);
-		}
-		store.set(key, { ...value, expiresAt: Date.now() + TTL_MS });
-	},
-};

package/.next/standalone/src/lib/proof/lease.ts

@@ -1,117 +0,0 @@
-/**
- * Human edit-lease store (in-memory, globalThis for hot-reload survival).
- *
- * Namespace choice (workspacing): the first argument to every public function
- * is `ns` — a namespace string that MUST be the workspace rootDir (or wsId in
- * future phases).  The internal map key is `${ns}\u0000${relPath}`.  Two
- * workspaces that share the same relative path (e.g. "notes.md") therefore
- * never collide.  Phase B routes pass rootDir from resolveWorkspaceForUser;
- * Phase A callers pass getRootDir() or tmpRoot in tests.
- *
- * A lease is set when a human opens a .md doc in the editor and refreshed
- * via heartbeat while the doc stays open.  Its presence makes collab-state
- * "active" even before the human has typed a single suggestion.
- *
- * TTL: LEASE_TTL_MS (default 90 s). Editor should heartbeat every ~30 s.
- *
- * Collab-generation counter:
- *   - Starts at 0 per (ns, path).
- *   - Increments on EVERY 0→1 transition (first setLease, or setLease after
- *     all prior leases expired) AND on every 1→0 transition (clearLease or
- *     expiry-on-read).
- *   - X-Collab-Revision = sidecar.revision + leaseGeneration(ns, path).
- */
-
-export const LEASE_TTL_MS = 90_000;
-
-interface LeaseEntry {
-	userId: string;
-	expiresAt: number;
-}
-
-interface LeaseStore {
-	leases: Map<string, LeaseEntry>;
-	generations: Map<string, number>;
-}
-
-const g = globalThis as typeof globalThis & { __wikiLeaseStore?: LeaseStore };
-if (!g.__wikiLeaseStore) {
-	g.__wikiLeaseStore = { leases: new Map(), generations: new Map() };
-}
-
-function store(): LeaseStore {
-	return g.__wikiLeaseStore!;
-}
-
-function storeKey(ns: string, relPath: string): string {
-	return `${ns}\u0000${relPath}`;
-}
-
-/** True if (ns, relPath) has a non-expired lease RIGHT NOW (lazy-sweeps on check). */
-function isLeaseActiveInternal(ns: string, relPath: string): boolean {
-	const s = store();
-	const key = storeKey(ns, relPath);
-	const entry = s.leases.get(key);
-	if (!entry) return false;
-	if (Date.now() >= entry.expiresAt) {
-		s.leases.delete(key);
-		// 1→0 transition: bump generation
-		s.generations.set(key, (s.generations.get(key) ?? 0) + 1);
-		return false;
-	}
-	return true;
-}
-
-/**
- * Set (or refresh) a lease for (ns, relPath) by userId.
- * Bumps the generation counter on a 0→1 transition.
- * `ns` must be the workspace rootDir (or a stable workspace identifier).
- */
-export function setLease(ns: string, relPath: string, userId: string, ttlMs = LEASE_TTL_MS): void {
-	const s = store();
-	const key = storeKey(ns, relPath);
-	const wasActive = isLeaseActiveInternal(ns, relPath);
-	s.leases.set(key, { userId, expiresAt: Date.now() + ttlMs });
-	if (!wasActive) {
-		// 0→1 transition: bump generation
-		s.generations.set(key, (s.generations.get(key) ?? 0) + 1);
-	}
-}
-
-/** True if (ns, relPath) has a current non-expired lease. */
-export function hasActiveLease(ns: string, relPath: string): boolean {
-	return isLeaseActiveInternal(ns, relPath);
-}
-
-/**
- * Clear the lease for (ns, relPath) (on doc close).
- * Only clears if the existing lease belongs to userId.
- * Bumps generation on removal.
- */
-export function clearLease(ns: string, relPath: string, userId: string): void {
-	const s = store();
-	const key = storeKey(ns, relPath);
-	const entry = s.leases.get(key);
-	if (!entry) return;
-	if (entry.userId === userId) {
-		s.leases.delete(key);
-		// 1→0 transition: bump generation
-		s.generations.set(key, (s.generations.get(key) ?? 0) + 1);
-	}
-}
-
-/**
- * Returns the monotonic-ish collab generation for (ns, relPath).
- * Increments on every 0→1 and 1→0 lease transition.
- */
-export function leaseGeneration(ns: string, relPath: string): number {
-	const key = storeKey(ns, relPath);
-	return store().generations.get(key) ?? 0;
-}
-
-/** Reset store — for tests only. */
-export function _resetLeaseStore(): void {
-	const s = store();
-	s.leases.clear();
-	s.generations.clear();
-}

package/.next/standalone/src/lib/proof/mutex.ts

@@ -1,36 +0,0 @@
-// Workspacing note (Phase B): callers must prefix the lock key with rootDir
-// (or wsId) to ensure two workspaces sharing the same relPath do not serialize
-// against each other. e.g. key = `${rootDir}\0${relPath}`. Phase B call sites
-// will make this change when route threading is done.
-import { withFileLock } from "./file-lock";
-
-const locks = new Map<string, Promise<void>>();
-
-/**
- * Acquire an in-process mutex (for same-process serialisation) and then a
- * cross-process file lock (for multi-replica safety).
- *
- * The in-process mutex is held for the outer scope so that same-process
- * callers never race for the file lock. The file lock is acquired inside so
- * that different processes can safely share the same data files.
- */
-export async function withFileMutex<T>(
-	filePath: string,
-	fn: () => Promise<T>,
-): Promise<T> {
-	while (locks.has(filePath)) {
-		await locks.get(filePath);
-	}
-	let release!: () => void;
-	const p = new Promise<void>((r) => {
-		release = r;
-	});
-	locks.set(filePath, p);
-	try {
-		// Cross-process file lock wraps the inner fn.
-		return await withFileLock(filePath, fn);
-	} finally {
-		locks.delete(filePath);
-		release();
-	}
-}