wiki-viewer 1.0.0 → 1.0.1

package/.next/standalone/src/tests/proof/comments-ops.test.ts

@@ -0,0 +1,177 @@
+import { test, before, after } from "node:test";
+import assert from "node:assert/strict";
+import { mkdtemp, writeFile, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import { applyOps, readSnapshot } from "../../lib/proof/ops-applier.js";
+import { setRootDir } from "../../lib/root-dir.js";
+
+let tmpRoot: string;
+
+before(async () => {
+	tmpRoot = await mkdtemp(path.join(tmpdir(), "wiki-comment-test-"));
+	setRootDir(tmpRoot);
+});
+
+after(async () => {
+	await rm(tmpRoot, { recursive: true, force: true });
+});
+
+async function writeDoc(name: string, content: string): Promise<void> {
+	await writeFile(path.join(tmpRoot, name), content, "utf-8");
+}
+
+test("comment.add — sidecar has comment with one turn", async () => {
+	await writeDoc("cadd.md", "# Title\n\nA paragraph.\n");
+	const snap = await readSnapshot(tmpRoot, "cadd.md");
+	assert.ok(snap !== null);
+	const paraRef = snap!.blocks[1].ref;
+
+	const result = await applyOps({
+		rootDir: tmpRoot,
+		mdPath: "cadd.md",
+		baseRevision: 0,
+		by: "human",
+		ops: [{ type: "comment.add", ref: paraRef, text: "First comment." }],
+	});
+
+	assert.ok(result.ok, `expected ok: ${JSON.stringify(result)}`);
+	assert.equal(result.ok ? result.snapshot.comments.length : -1, 1);
+	const c = result.ok ? result.snapshot.comments[0] : null;
+	assert.ok(c !== null);
+	assert.equal(c!.resolved, false);
+	assert.equal(c!.ref, paraRef);
+	assert.equal(c!.turns.length, 1);
+	assert.equal(c!.turns[0].text, "First comment.");
+	assert.equal(c!.turns[0].by, "human");
+});
+
+test("comment.reply — existing comment gains second turn", async () => {
+	await writeDoc("creply.md", "# Title\n\nParagraph.\n");
+	const snap = await readSnapshot(tmpRoot, "creply.md");
+	const paraRef = snap!.blocks[1].ref;
+
+	const addResult = await applyOps({
+		rootDir: tmpRoot,
+		mdPath: "creply.md",
+		baseRevision: 0,
+		by: "human",
+		ops: [{ type: "comment.add", ref: paraRef, text: "Why?" }],
+	});
+	assert.ok(addResult.ok);
+	const commentId = addResult.ok ? addResult.snapshot.comments[0]?.id : null;
+	assert.ok(commentId);
+
+	const replyResult = await applyOps({
+		rootDir: tmpRoot,
+		mdPath: "creply.md",
+		baseRevision: 1,
+		by: "ai:claude",
+		ops: [{ type: "comment.reply", commentId: commentId!, text: "Because reasons." }],
+	});
+	assert.ok(replyResult.ok, `expected ok: ${JSON.stringify(replyResult)}`);
+	const c = replyResult.ok
+		? replyResult.snapshot.comments.find((x) => x.id === commentId)
+		: null;
+	assert.ok(c, "comment should be in snapshot");
+	assert.equal(c!.turns.length, 2);
+	assert.equal(c!.turns[1].text, "Because reasons.");
+	assert.equal(c!.turns[1].by, "ai:claude");
+});
+
+test("comment.resolve — resolved=true + event emitted", async () => {
+	await writeDoc("cresolve.md", "# Title\n\nParagraph.\n");
+	const snap = await readSnapshot(tmpRoot, "cresolve.md");
+	const paraRef = snap!.blocks[1].ref;
+
+	const addResult = await applyOps({
+		rootDir: tmpRoot,
+		mdPath: "cresolve.md",
+		baseRevision: 0,
+		by: "human",
+		ops: [{ type: "comment.add", ref: paraRef, text: "Open thread." }],
+	});
+	assert.ok(addResult.ok);
+	const commentId = addResult.ok ? addResult.snapshot.comments[0]?.id : null;
+	assert.ok(commentId);
+
+	const resolveResult = await applyOps({
+		rootDir: tmpRoot,
+		mdPath: "cresolve.md",
+		baseRevision: 1,
+		by: "human",
+		ops: [{ type: "comment.resolve", commentId: commentId! }],
+	});
+	assert.ok(resolveResult.ok, `expected ok: ${JSON.stringify(resolveResult)}`);
+	const c = resolveResult.ok
+		? resolveResult.snapshot.comments.find((x) => x.id === commentId)
+		: null;
+	assert.ok(c, "comment still present in snapshot");
+	assert.equal(c!.resolved, true);
+	// event emitted
+	const evt = resolveResult.ok
+		? resolveResult.emittedEvents.find((e) => e.type === "comment.resolved")
+		: null;
+	assert.ok(evt, "comment.resolved event should be emitted");
+	assert.equal((evt as unknown as { commentId: string } | null)?.commentId, commentId);
+});
+
+test("comment.reopen — resolved=false + event emitted", async () => {
+	await writeDoc("creopen.md", "# Title\n\nParagraph.\n");
+	const snap = await readSnapshot(tmpRoot, "creopen.md");
+	const paraRef = snap!.blocks[1].ref;
+
+	// add then resolve
+	const addResult = await applyOps({
+		rootDir: tmpRoot,
+		mdPath: "creopen.md",
+		baseRevision: 0,
+		by: "human",
+		ops: [{ type: "comment.add", ref: paraRef, text: "Thread." }],
+	});
+	assert.ok(addResult.ok);
+	const commentId = addResult.ok ? addResult.snapshot.comments[0]?.id : null;
+	assert.ok(commentId);
+
+	const resolveResult = await applyOps({
+		rootDir: tmpRoot,
+		mdPath: "creopen.md",
+		baseRevision: 1,
+		by: "human",
+		ops: [{ type: "comment.resolve", commentId: commentId! }],
+	});
+	assert.ok(resolveResult.ok);
+
+	const reopenResult = await applyOps({
+		rootDir: tmpRoot,
+		mdPath: "creopen.md",
+		baseRevision: 2,
+		by: "human",
+		ops: [{ type: "comment.reopen", commentId: commentId! }],
+	});
+	assert.ok(reopenResult.ok, `expected ok: ${JSON.stringify(reopenResult)}`);
+	const c = reopenResult.ok
+		? reopenResult.snapshot.comments.find((x) => x.id === commentId)
+		: null;
+	assert.ok(c);
+	assert.equal(c!.resolved, false);
+	// event emitted
+	const evt = reopenResult.ok
+		? reopenResult.emittedEvents.find((e) => e.type === "comment.reopened")
+		: null;
+	assert.ok(evt, "comment.reopened event should be emitted");
+});
+
+test("comment.reply to nonexistent commentId → 409 COMMENT_NOT_FOUND", async () => {
+	await writeDoc("cnotfound.md", "# Title\n\nParagraph.\n");
+	const result = await applyOps({
+		rootDir: tmpRoot,
+		mdPath: "cnotfound.md",
+		baseRevision: 0,
+		by: "human",
+		ops: [{ type: "comment.reply", commentId: "cdeadbeef", text: "Ghost reply." }],
+	});
+	assert.ok(!result.ok);
+	assert.equal(result.ok ? "" : result.code, "COMMENT_NOT_FOUND");
+	assert.equal(result.ok ? 0 : result.status, 409);
+});

package/.next/standalone/src/tests/proof/editor-roundtrip.test.ts

@@ -0,0 +1,85 @@
+/**
+ * §7.6 Roundtrip fidelity: proof-span survives markdownToHtml → htmlToMarkdown.
+ */
+import assert from "node:assert/strict";
+import { describe, it, test } from "node:test";
+import { markdownToHtml } from "@/lib/markdown/to-html";
+import { htmlToMarkdown } from "@/lib/markdown/to-markdown";
+import { ProofSpan } from "@/components/editor/extensions/proof-span";
+
+const SPAN_TAG = "proof-span";
+
+/** Collect all attribute key=value pairs from a proof-span tag in a string. */
+function extractSpanAttrs(src: string): Map<string, string> {
+	const match = src.match(/<proof-span\b([^>]*)>/);
+	if (!match) return new Map();
+	const attrsRaw = match[1];
+	const map = new Map<string, string>();
+	const attrRe = /([a-z-]+)="([^"]*)"/g;
+	let m: RegExpExecArray | null;
+	while ((m = attrRe.exec(attrsRaw)) !== null) {
+		map.set(m[1], m[2]);
+	}
+	return map;
+}
+
+describe("editor-roundtrip proof-span", () => {
+	it("preserves proof-span tag and inner content through html roundtrip", async () => {
+		const md =
+			'Hello <proof-span id="p123" origin="ai" by="ai:claude" at="2026-01-01T00:00:00Z" basis="described">hello world</proof-span> end.';
+
+		const html = await markdownToHtml(md);
+
+		// The HTML should contain a proof-span element (TipTap schema is client-side;
+		// here we verify the remark pipeline preserves raw HTML passthrough).
+		assert.ok(html.includes(SPAN_TAG), `HTML should contain <${SPAN_TAG}> tag:\n${html}`);
+		assert.ok(html.includes("hello world"), "HTML should contain inner text");
+
+		const roundtripped = htmlToMarkdown(html);
+
+		assert.ok(
+			roundtripped.includes(`<${SPAN_TAG}`),
+			`Roundtripped markdown should contain <${SPAN_TAG}> tag:\n${roundtripped}`,
+		);
+		assert.ok(
+			roundtripped.includes("hello world"),
+			"Roundtripped markdown should contain inner text",
+		);
+
+		const origAttrs = extractSpanAttrs(md);
+		const rtAttrs = extractSpanAttrs(roundtripped);
+
+		// Every attr in the original must survive the roundtrip.
+		for (const [key, value] of origAttrs) {
+			assert.equal(
+				rtAttrs.get(key),
+				value,
+				`Attribute '${key}' should survive roundtrip. Expected '${value}', got '${rtAttrs.get(key)}'`,
+			);
+		}
+	});
+
+	it("TipTap ProofSpan mark schema matches spec", () => {
+		const inst = ProofSpan.configure({});
+		assert.equal(inst.name, "proofSpan");
+		const spec = (inst as { config: { parseHTML?: () => unknown[] } }).config;
+		assert.ok(spec.parseHTML, "parseHTML defined");
+		const parseRules = (spec.parseHTML as () => Array<{ tag: string }>)();
+		assert.equal(parseRules[0].tag, "proof-span");
+	});
+
+	it("preserves proof-span with wiki-link child", async () => {
+		const md =
+			'Text <proof-span id="p456" origin="ai" by="ai:cursor" at="2026-01-01T00:00:00Z" basis="inferred">see [[my-page]]</proof-span>.';
+
+		const html = await markdownToHtml(md);
+		const roundtripped = htmlToMarkdown(html);
+
+		assert.ok(roundtripped.includes(`<${SPAN_TAG}`), "span tag preserved");
+		// Wiki-link should be preserved (either as [[my-page]] or as anchor markup)
+		assert.ok(
+			roundtripped.includes("my-page"),
+			"wiki-link slug preserved inside span",
+		);
+	});
+});

package/.next/standalone/src/tests/proof/external-edit.test.ts

@@ -0,0 +1,58 @@
+import { test, before, after } from "node:test";
+import assert from "node:assert/strict";
+import { mkdtemp, writeFile, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import { readSnapshot } from "../../lib/proof/ops-applier.js";
+import { setRootDir } from "../../lib/root-dir.js";
+
+let tmpRoot: string;
+
+before(async () => {
+	tmpRoot = await mkdtemp(path.join(tmpdir(), "wiki-ext-edit-test-"));
+	setRootDir(tmpRoot);
+});
+
+after(async () => {
+	await rm(tmpRoot, { recursive: true, force: true });
+});
+
+test("readSnapshot: detects external edit and emits file.externallyEdited event", async () => {
+	const mdFile = path.join(tmpRoot, "ext-edit.md");
+	const original = "# Title\n\nOriginal content.\n";
+
+	// Write initial content
+	await writeFile(mdFile, original, "utf-8");
+
+	// Take first snapshot — establishes fingerprint in sidecar
+	const snap0 = await readSnapshot(tmpRoot, "ext-edit.md");
+	assert.ok(snap0 !== null);
+	assert.equal(snap0!.revision, 0);
+
+	// Externally modify the file on disk (bypass ops-applier)
+	const modified = "# Title\n\nExternally modified content.\n";
+	await writeFile(mdFile, modified, "utf-8");
+
+	// readSnapshot should detect the mismatch and bump revision + emit event
+	const snap1 = await readSnapshot(tmpRoot, "ext-edit.md");
+	assert.ok(snap1 !== null);
+	assert.equal(snap1!.revision, 1, "revision should be bumped after external edit");
+
+	// The last event in the sidecar should be file.externallyEdited
+	// We verify via the lastEventId being > the initial snap
+	assert.ok(snap1!.lastEventId >= 0, "lastEventId should be set");
+});
+
+test("readSnapshot: no false positive when file unchanged", async () => {
+	const mdFile = path.join(tmpRoot, "no-change.md");
+	await writeFile(mdFile, "# Stable\n\nContent.\n", "utf-8");
+
+	const snap0 = await readSnapshot(tmpRoot, "no-change.md");
+	assert.ok(snap0 !== null);
+	assert.equal(snap0!.revision, 0);
+
+	// Read again without any external change
+	const snap1 = await readSnapshot(tmpRoot, "no-change.md");
+	assert.ok(snap1 !== null);
+	assert.equal(snap1!.revision, 0, "revision must not change when file is unmodified");
+});

package/.next/standalone/src/tests/proof/file-lock.test.ts

@@ -0,0 +1,80 @@
+/**
+ * Basic tests for withFileLock / withFileMutex cross-process safety layer.
+ */
+import { test, before, after } from "node:test";
+import assert from "node:assert/strict";
+import { mkdtemp, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import path from "node:path";
+
+let tmpHome: string;
+
+before(async () => {
+	tmpHome = await mkdtemp(path.join(tmpdir(), "file-lock-test-"));
+	process.env.HOME = tmpHome;
+});
+
+after(async () => {
+	await rm(tmpHome, { recursive: true, force: true });
+});
+
+import { withFileLock } from "../../lib/proof/file-lock.js";
+import { withFileMutex } from "../../lib/proof/mutex.js";
+
+test("withFileLock: acquires and releases without deadlock", async () => {
+	const result = await withFileLock("test-key-1", async () => {
+		return 42;
+	});
+	assert.equal(result, 42);
+});
+
+test("withFileLock: sequential calls on same key succeed", async () => {
+	const r1 = await withFileLock("test-key-seq", async () => "first");
+	const r2 = await withFileLock("test-key-seq", async () => "second");
+	assert.equal(r1, "first");
+	assert.equal(r2, "second");
+});
+
+test("withFileLock: propagates errors and releases lock", async () => {
+	await assert.rejects(
+		() => withFileLock("test-key-err", async () => { throw new Error("boom"); }),
+		/boom/,
+	);
+	// Should be releasable again
+	const r = await withFileLock("test-key-err", async () => "ok");
+	assert.equal(r, "ok");
+});
+
+test("withFileMutex: serialises concurrent in-process callers", async () => {
+	const results: number[] = [];
+	await Promise.all([
+		withFileMutex("mutex-concurrent-key", async () => {
+			results.push(1);
+			await new Promise((r) => setTimeout(r, 10));
+			results.push(2);
+		}),
+		withFileMutex("mutex-concurrent-key", async () => {
+			results.push(3);
+		}),
+	]);
+	// Serialised: 1, 2 must appear before 3.
+	assert.deepEqual(results, [1, 2, 3]);
+});
+
+test("withFileMutex: different keys run concurrently", async () => {
+	const log: string[] = [];
+	await Promise.all([
+		withFileMutex("key-A", async () => {
+			log.push("A-start");
+			await new Promise((r) => setTimeout(r, 20));
+			log.push("A-end");
+		}),
+		withFileMutex("key-B", async () => {
+			log.push("B-start");
+			log.push("B-end");
+		}),
+	]);
+	// B can start before A ends (different keys = no contention).
+	assert.ok(log.includes("B-start"));
+	assert.ok(log.includes("A-end"));
+});

package/.next/standalone/src/tests/proof/glob.test.ts

@@ -0,0 +1,82 @@
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { matchGlob } from "../../lib/proof/glob.js";
+
+// ── ** matches ────────────────────────────────────────────────────────────────
+
+test("** matches file in root", () => {
+	assert.ok(matchGlob("**/*", "notes.md"));
+});
+
+test("** matches file in subdirectory", () => {
+	assert.ok(matchGlob("**/*", "work/notes.md"));
+});
+
+test("** matches deeply nested file", () => {
+	assert.ok(matchGlob("**/*", "a/b/c/d/notes.md"));
+});
+
+test("**/*.md matches only .md files at any depth", () => {
+	assert.ok(matchGlob("**/*.md", "notes.md"));
+	assert.ok(matchGlob("**/*.md", "work/notes.md"));
+	assert.ok(matchGlob("**/*.md", "a/b/notes.md"));
+	assert.ok(!matchGlob("**/*.md", "notes.txt"));
+	assert.ok(!matchGlob("**/*.md", "work/notes.txt"));
+});
+
+test("** matches zero path segments (root file)", () => {
+	assert.ok(matchGlob("**/*", "root.md"));
+});
+
+// ── * does not cross / ────────────────────────────────────────────────────────
+
+test("* does not match path separator", () => {
+	assert.ok(!matchGlob("*.md", "work/notes.md"));
+	assert.ok(matchGlob("*.md", "notes.md"));
+});
+
+test("* matches empty string at same level", () => {
+	assert.ok(matchGlob("notes*", "notes.md"));
+	assert.ok(matchGlob("notes*", "notes"));
+	assert.ok(!matchGlob("notes*", "a/notes.md"));
+});
+
+// ── ? matches single non-slash char ──────────────────────────────────────────
+
+test("? matches single character", () => {
+	assert.ok(matchGlob("note?.md", "notes.md"));
+	assert.ok(matchGlob("note?.md", "notex.md"));
+	assert.ok(!matchGlob("note?.md", "notexy.md"));
+	assert.ok(!matchGlob("note?.md", "work/notes.md"));
+});
+
+// ── Literal match ─────────────────────────────────────────────────────────────
+
+test("Literal pattern matches exact path", () => {
+	assert.ok(matchGlob("notes/work.md", "notes/work.md"));
+	assert.ok(!matchGlob("notes/work.md", "notes/other.md"));
+});
+
+test("Literal pattern anchored — no partial match", () => {
+	assert.ok(!matchGlob("notes", "notes/work.md"));
+	assert.ok(!matchGlob("notes.md", "xnotes.md"));
+});
+
+// ── Prefix patterns ───────────────────────────────────────────────────────────
+
+test("work/** matches files under work/", () => {
+	assert.ok(matchGlob("work/**", "work/notes.md"));
+	assert.ok(matchGlob("work/**", "work/sub/notes.md"));
+	assert.ok(!matchGlob("work/**", "other/notes.md"));
+	assert.ok(!matchGlob("work/**", "notes.md"));
+});
+
+// ── Regex special char escaping ────────────────────────────────────────────────
+
+test("Dots in pattern treated as literal", () => {
+	// notes.md pattern: dot is literal, must not match notesXmd
+	assert.ok(matchGlob("notes.md", "notes.md"));
+	assert.ok(!matchGlob("notes.md", "notesXmd"));
+	// Pattern without dots matches its own literal value
+	assert.ok(matchGlob("notesXmd", "notesXmd"));
+});

package/.next/standalone/src/tests/proof/helpers/auth-session.ts

@@ -0,0 +1,27 @@
+/**
+ * Shared helper: create a signed-in user session for use in route handler tests.
+ * Callers must set process.env.HOME to an isolated tmpdir before importing auth/server.
+ */
+
+export async function makeUserSession(): Promise<string> {
+	const { auth, authReady } = await import("../../../lib/auth/server.js");
+	await authReady();
+	const res = await auth.api.signUpEmail({
+		body: {
+			email: `t${Date.now()}${Math.random().toString(36).slice(2, 6)}@test.local`,
+			password: "test1234!",
+			name: "Test User",
+		},
+		asResponse: true,
+	});
+	if (!res.ok) {
+		const text = await res.text();
+		throw new Error("signUpEmail failed: " + res.status + " " + text);
+	}
+	const setCookie = res.headers.get("set-cookie") ?? "";
+	const cookies = setCookie
+		.split(/,(?=[^ ])/)
+		.map((c) => c.split(";")[0].trim())
+		.join("; ");
+	return cookies;
+}

package/.next/standalone/src/tests/proof/markdown-to-html.test.ts

@@ -0,0 +1,46 @@
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { markdownToHtml } from "../../lib/markdown/to-html.js";
+
+// These tests guard the read-only viewer path (sanitize: true). The sanitize
+// pipeline must actually run end to end: a missing HTML parser previously made
+// it throw, which blanked the viewer body. Keep runtime coverage here.
+
+test("sanitize path renders body, tables, and headings", async () => {
+	const md = `## Section
+
+<table><tbody><tr><td><p>Cell</p></td></tr></tbody></table>
+
+Paragraph text.`;
+	const html = await markdownToHtml(md, { sanitize: true });
+	assert.ok(html.includes("<h2"), "heading should render");
+	assert.ok(html.includes("<table"), "raw HTML table should survive");
+	assert.ok(html.includes("Paragraph text."), "body should not be dropped");
+});
+
+test("sanitize path strips scripts, event handlers, and javascript: urls", async () => {
+	const md = `<img src=x onerror="alert(1)">
+<script>alert(2)</script>
+
+[x](javascript:alert(3))`;
+	const html = await markdownToHtml(md, { sanitize: true });
+	assert.ok(!html.includes("onerror"), "onerror handler must be stripped");
+	assert.ok(!html.includes("<script"), "script tag must be stripped");
+	assert.ok(!html.includes("javascript:"), "javascript: url must be stripped");
+});
+
+test("sanitize path preserves the wiki-link contract", async () => {
+	const html = await markdownToHtml("See [[my-page|Alias]] and [[other#sec]].", {
+		sanitize: true,
+	});
+	assert.ok(html.includes('data-wiki-link="true"'), "wiki-link marker kept");
+	assert.ok(html.includes('data-slug="my-page"'), "slug kept");
+	assert.ok(html.includes('data-alias="Alias"'), "alias kept");
+	assert.ok(html.includes('data-anchor="sec"'), "anchor kept");
+});
+
+test("unsanitized editor path leaves HTML untouched", async () => {
+	const md = `<table><tbody><tr><td>x</td></tr></tbody></table>`;
+	const html = await markdownToHtml(md);
+	assert.ok(html.includes("<table"), "editor path keeps raw HTML");
+});