wiki-viewer 1.0.0 → 1.1.0

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

@@ -0,0 +1,368 @@
+import { test, before, after } from "node:test";
+import assert from "node:assert/strict";
+import { mkdtemp, writeFile, readFile, 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";
+import { idempotency } from "../../lib/proof/idempotency.js";
+
+let tmpRoot: string;
+
+before(async () => {
+	tmpRoot = await mkdtemp(path.join(tmpdir(), "wiki-proof-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");
+}
+
+async function readDoc(name: string): Promise<string> {
+	return readFile(path.join(tmpRoot, name), "utf-8");
+}
+
+test("readSnapshot returns null for missing file", async () => {
+	const snap = await readSnapshot(tmpRoot, "nonexistent.md");
+	assert.equal(snap, null);
+});
+
+test("readSnapshot returns blocks for existing file", async () => {
+	await writeDoc("snap-test.md", "# Title\n\nParagraph.\n");
+	const snap = await readSnapshot(tmpRoot, "snap-test.md");
+	assert.ok(snap !== null);
+	assert.equal(snap!.blocks.length, 2);
+	assert.equal(snap!.blocks[0].type, "heading");
+	assert.equal(snap!.blocks[1].type, "paragraph");
+	assert.equal(snap!.revision, 0);
+});
+
+test("block.replace happy path", async () => {
+	await writeDoc("replace.md", "# Title\n\nOriginal paragraph.\n");
+	const snap = await readSnapshot(tmpRoot, "replace.md");
+	const paraRef = snap!.blocks[1].ref;
+
+	const result = await applyOps({
+		rootDir: tmpRoot,
+		mdPath: "replace.md",
+		baseRevision: 0,
+		by: "human",
+		ops: [{ type: "block.replace", ref: paraRef, markdown: "Replaced paragraph." }],
+	});
+
+	assert.ok(result.ok, `expected ok: ${JSON.stringify(result)}`);
+	assert.equal(result.ok ? result.snapshot.revision : -1, 1);
+	const content = await readDoc("replace.md");
+	assert.ok(content.includes("Replaced paragraph."), `content: ${content}`);
+	assert.ok(!content.includes("Original paragraph."), `old content: ${content}`);
+});
+
+test("block.insertAfter happy path", async () => {
+	await writeDoc("insert.md", "# Title\n\nParagraph.\n");
+	const snap = await readSnapshot(tmpRoot, "insert.md");
+	const titleRef = snap!.blocks[0].ref;
+
+	const result = await applyOps({
+		rootDir: tmpRoot,
+		mdPath: "insert.md",
+		baseRevision: 0,
+		by: "human",
+		ops: [{ type: "block.insertAfter", ref: titleRef, markdown: "New paragraph." }],
+	});
+
+	assert.ok(result.ok);
+	const content = await readDoc("insert.md");
+	assert.ok(content.includes("New paragraph."), `inserted: ${content}`);
+	assert.ok(content.includes("# Title"), `title preserved: ${content}`);
+});
+
+test("block.insertBefore happy path", async () => {
+	await writeDoc("insertbefore.md", "# Title\n\nParagraph.\n");
+	const snap = await readSnapshot(tmpRoot, "insertbefore.md");
+	const paraRef = snap!.blocks[1].ref;
+
+	const result = await applyOps({
+		rootDir: tmpRoot,
+		mdPath: "insertbefore.md",
+		baseRevision: 0,
+		by: "human",
+		ops: [{ type: "block.insertBefore", ref: paraRef, markdown: "Before." }],
+	});
+
+	assert.ok(result.ok);
+	const content = await readDoc("insertbefore.md");
+	assert.ok(content.includes("Before."), `inserted: ${content}`);
+});
+
+test("block.delete happy path", async () => {
+	await writeDoc("delete.md", "# Title\n\nTo delete.\n\n## Section\n");
+	const snap = await readSnapshot(tmpRoot, "delete.md");
+	const paraRef = snap!.blocks[1].ref;
+
+	const result = await applyOps({
+		rootDir: tmpRoot,
+		mdPath: "delete.md",
+		baseRevision: 0,
+		by: "human",
+		ops: [{ type: "block.delete", ref: paraRef }],
+	});
+
+	assert.ok(result.ok);
+	const content = await readDoc("delete.md");
+	assert.ok(!content.includes("To delete."), `deleted: ${content}`);
+	assert.ok(content.includes("# Title"), `title preserved: ${content}`);
+});
+
+test("block.append adds to end", async () => {
+	await writeDoc("append.md", "# Title\n");
+	const result = await applyOps({
+		rootDir: tmpRoot,
+		mdPath: "append.md",
+		baseRevision: 0,
+		by: "human",
+		ops: [{ type: "block.append", markdown: "Appended." }],
+	});
+
+	assert.ok(result.ok);
+	const content = await readDoc("append.md");
+	assert.ok(content.includes("Appended."), `appended: ${content}`);
+});
+
+test("block.prepend adds to start", async () => {
+	await writeDoc("prepend.md", "# Title\n");
+	const result = await applyOps({
+		rootDir: tmpRoot,
+		mdPath: "prepend.md",
+		baseRevision: 0,
+		by: "human",
+		ops: [{ type: "block.prepend", markdown: "Prepended." }],
+	});
+
+	assert.ok(result.ok);
+	const content = await readDoc("prepend.md");
+	assert.ok(content.startsWith("Prepended."), `prepended: ${content}`);
+});
+
+test("STALE_REVISION returned when baseRevision wrong", async () => {
+	await writeDoc("stale.md", "# Title\n\nParagraph.\n");
+	const snap = await readSnapshot(tmpRoot, "stale.md");
+	const paraRef = snap!.blocks[1].ref;
+
+	const result = await applyOps({
+		rootDir: tmpRoot,
+		mdPath: "stale.md",
+		baseRevision: 99, // wrong
+		by: "human",
+		ops: [{ type: "block.replace", ref: paraRef, markdown: "New." }],
+	});
+
+	assert.ok(!result.ok);
+	assert.equal(result.ok ? "" : result.code, "STALE_REVISION");
+	assert.equal(result.ok ? 0 : result.status, 409);
+});
+
+test("BLOCK_NOT_FOUND returned for stale ref", async () => {
+	await writeDoc("notfound.md", "# Title\n");
+
+	const result = await applyOps({
+		rootDir: tmpRoot,
+		mdPath: "notfound.md",
+		baseRevision: 0,
+		by: "human",
+		ops: [{ type: "block.replace", ref: "bdeadbeef", markdown: "New." }],
+	});
+
+	assert.ok(!result.ok);
+	assert.equal(result.ok ? "" : result.code, "BLOCK_NOT_FOUND");
+	assert.equal(result.ok ? 0 : result.status, 409);
+});
+
+test("FILE_NOT_FOUND for missing file", async () => {
+	const result = await applyOps({
+		rootDir: tmpRoot,
+		mdPath: "does-not-exist.md",
+		baseRevision: 0,
+		by: "human",
+		ops: [],
+	});
+
+	assert.ok(!result.ok);
+	assert.equal(result.ok ? "" : result.code, "FILE_NOT_FOUND");
+	assert.equal(result.ok ? 0 : result.status, 404);
+});
+
+test("AI insertAfter wraps text in proof-span", async () => {
+	await writeDoc("ai-wrap.md", "# Title\n\nParagraph.\n");
+	const snap = await readSnapshot(tmpRoot, "ai-wrap.md");
+	const titleRef = snap!.blocks[0].ref;
+
+	const result = await applyOps({
+		rootDir: tmpRoot,
+		mdPath: "ai-wrap.md",
+		baseRevision: 0,
+		by: "ai:claude",
+		ops: [{
+			type: "block.insertAfter",
+			ref: titleRef,
+			markdown: "AI wrote this content.",
+			basis: "described",
+			basisDetail: "user asked for it",
+		}],
+	});
+
+	assert.ok(result.ok, `expected ok: ${JSON.stringify(result)}`);
+	const content = await readDoc("ai-wrap.md");
+	assert.ok(content.includes("<proof-span"), `proof-span missing: ${content}`);
+	assert.ok(content.includes('origin="ai"'), `origin missing: ${content}`);
+	assert.ok(content.includes('by="ai:claude"'), `by missing: ${content}`);
+	assert.ok(content.includes("AI wrote this content."), `content missing: ${content}`);
+});
+
+test("comment.add and comment.reply ops", async () => {
+	await writeDoc("comment.md", "# Title\n\nParagraph.\n");
+	const snap = await readSnapshot(tmpRoot, "comment.md");
+	const paraRef = snap!.blocks[1].ref;
+
+	const addResult = await applyOps({
+		rootDir: tmpRoot,
+		mdPath: "comment.md",
+		baseRevision: 0,
+		by: "human",
+		ops: [{ type: "comment.add", ref: paraRef, text: "Why this?" }],
+	});
+	assert.ok(addResult.ok);
+	const commentId = addResult.ok ? addResult.snapshot.comments[0]?.id : null;
+	assert.ok(commentId, "comment should have an id");
+
+	const replyResult = await applyOps({
+		rootDir: tmpRoot,
+		mdPath: "comment.md",
+		baseRevision: 1,
+		by: "ai:claude",
+		ops: [{ type: "comment.reply", commentId: commentId!, text: "Because of X." }],
+	});
+	assert.ok(replyResult.ok);
+	const comment = replyResult.ok
+		? replyResult.snapshot.comments.find((c) => c.id === commentId)
+		: null;
+	assert.ok(comment, "comment should be in snapshot");
+	assert.equal(comment!.turns.length, 2, "should have 2 turns");
+	assert.equal(comment!.turns[1].text, "Because of X.");
+});
+
+test("suggestion.add and suggestion.accept", async () => {
+	await writeDoc("suggest.md", "# Title\n\nOriginal.\n");
+	const snap = await readSnapshot(tmpRoot, "suggest.md");
+	const paraRef = snap!.blocks[1].ref;
+
+	const addResult = await applyOps({
+		rootDir: tmpRoot,
+		mdPath: "suggest.md",
+		baseRevision: 0,
+		by: "ai:claude",
+		ops: [{
+			type: "suggestion.add",
+			ref: paraRef,
+			kind: "replace",
+			markdown: "Suggested replacement.",
+			basis: "described",
+		}],
+	});
+	assert.ok(addResult.ok, `add: ${JSON.stringify(addResult)}`);
+	const sugId = addResult.ok ? addResult.snapshot.suggestions[0]?.id : null;
+	assert.ok(sugId, "suggestion should have an id");
+
+	const acceptResult = await applyOps({
+		rootDir: tmpRoot,
+		mdPath: "suggest.md",
+		baseRevision: 1,
+		by: "human",
+		ops: [{ type: "suggestion.accept", suggestionId: sugId! }],
+	});
+	assert.ok(acceptResult.ok, `accept: ${JSON.stringify(acceptResult)}`);
+	// Suggestion should be gone from pending
+	const pending = acceptResult.ok ? acceptResult.snapshot.suggestions : [];
+	assert.equal(pending.length, 0, "no pending suggestions after accept");
+	// File should have new content
+	const content = await readDoc("suggest.md");
+	assert.ok(content.includes("Suggested replacement."), `content: ${content}`);
+});
+
+test("suggestion.reject moves to archive", async () => {
+	await writeDoc("reject.md", "# Title\n\nOriginal.\n");
+	const snap = await readSnapshot(tmpRoot, "reject.md");
+	const paraRef = snap!.blocks[1].ref;
+
+	const addResult = await applyOps({
+		rootDir: tmpRoot,
+		mdPath: "reject.md",
+		baseRevision: 0,
+		by: "ai:claude",
+		ops: [{
+			type: "suggestion.add",
+			ref: paraRef,
+			kind: "replace",
+			markdown: "Rejected suggestion.",
+		}],
+	});
+	assert.ok(addResult.ok);
+	const sugId = addResult.ok ? addResult.snapshot.suggestions[0]?.id : null;
+
+	const rejectResult = await applyOps({
+		rootDir: tmpRoot,
+		mdPath: "reject.md",
+		baseRevision: 1,
+		by: "human",
+		ops: [{ type: "suggestion.reject", suggestionId: sugId! }],
+	});
+	assert.ok(rejectResult.ok);
+	const pending = rejectResult.ok ? rejectResult.snapshot.suggestions : [];
+	assert.equal(pending.length, 0, "no pending suggestions after reject");
+	// File should NOT have been changed
+	const content = await readDoc("reject.md");
+	assert.ok(content.includes("Original."), `content unchanged: ${content}`);
+});
+
+test("events emitted for ops", async () => {
+	await writeDoc("events.md", "# Title\n\nParagraph.\n");
+	const snap = await readSnapshot(tmpRoot, "events.md");
+	const paraRef = snap!.blocks[1].ref;
+
+	const result = await applyOps({
+		rootDir: tmpRoot,
+		mdPath: "events.md",
+		baseRevision: 0,
+		by: "human",
+		ops: [{ type: "block.replace", ref: paraRef, markdown: "New." }],
+	});
+
+	assert.ok(result.ok);
+	assert.ok(result.ok && result.emittedEvents.length > 0, "events should be emitted");
+	assert.equal(result.ok ? result.emittedEvents[0].type : "", "block.replaced");
+});
+
+test("idempotency: same key returns cached response", async () => {
+	await writeDoc("idem.md", "# Title\n\nParagraph.\n");
+	const snap = await readSnapshot(tmpRoot, "idem.md");
+	const paraRef = snap!.blocks[1].ref;
+
+	const key = "test-idem-key-" + Date.now();
+	const payload = {
+		payloadHash: "abc",
+		status: 200,
+		body: JSON.stringify({ cached: true }),
+	};
+	idempotency.set(key, payload);
+
+	const cached = idempotency.get(key);
+	assert.ok(cached !== null, "cached entry should exist");
+	assert.equal(cached!.body, JSON.stringify({ cached: true }));
+	assert.equal(cached!.status, 200);
+
+	// Different key should not be cached
+	assert.equal(idempotency.get("other-key"), null);
+});

package/.next/standalone/src/tests/proof/owner-init.test.ts

@@ -0,0 +1,2 @@
+// Removed: /api/owner/init is now a 308 redirect to /signin (Better Auth).
+// No tests needed.

package/.next/standalone/src/tests/proof/parse-frontmatter.test.ts

@@ -0,0 +1,60 @@
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { parseFrontmatter } from "../../lib/markdown/parse-frontmatter.js";
+
+test("parses valid frontmatter and returns body", () => {
+	const text = `---
+title: Hello
+status: draft
+tags: [a, b, c]
+---
+
+# Body heading
+
+Some text.`;
+	const { data, body } = parseFrontmatter(text);
+	assert.equal(data.title, "Hello");
+	assert.equal(data.status, "draft");
+	assert.deepEqual(data.tags, ["a", "b", "c"]);
+	assert.ok(body.trimStart().startsWith("# Body heading"));
+});
+
+test("does not swallow body when a stray --- HR appears far below", () => {
+	// Opening fence, but the content is markdown (heading), and the only later
+	// `---` is a horizontal rule near the end. The parser must not treat the
+	// whole document as frontmatter.
+	const text = `---
+
+## title: Collapsed heading not YAML
+
+# Real Title
+
+Intro paragraph.
+
+---
+
+**Next step:** trailing line.`;
+	const { data, body } = parseFrontmatter(text);
+	assert.deepEqual(data, {}, "no keys should be parsed");
+	assert.ok(body.includes("# Real Title"), "body must retain the document");
+	assert.ok(body.includes("Intro paragraph."), "body must not be swallowed");
+});
+
+test("returns empty data when block has no YAML keys", () => {
+	const text = `---
+just some prose
+more prose
+---
+
+Body.`;
+	const { data, body } = parseFrontmatter(text);
+	assert.deepEqual(data, {});
+	assert.equal(body, text, "entire text preserved as body");
+});
+
+test("no frontmatter fence returns text unchanged", () => {
+	const text = `# Just a doc\n\nNo frontmatter here.`;
+	const { data, body } = parseFrontmatter(text);
+	assert.deepEqual(data, {});
+	assert.equal(body, text);
+});

package/.next/standalone/src/tests/proof/proof-span.test.ts

@@ -0,0 +1,98 @@
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { wrapAsProofSpan, unwrapProofSpans, revertProofSpan } from "../../lib/proof/proof-span.js";
+import type { SpanAttrs } from "../../lib/proof/types.js";
+
+const BASE_ATTRS: SpanAttrs = {
+	spanId: "p0001",
+	origin: "ai",
+	basis: "described",
+	by: "ai:claude",
+	at: "2026-01-01T00:00:00Z",
+};
+
+test("wrapAsProofSpan on paragraph wraps text content", () => {
+	const result = wrapAsProofSpan("The team will focus on three pillars.", BASE_ATTRS);
+	assert.ok(result !== null, "should not return null for paragraph");
+	assert.ok(result!.includes('<proof-span'), `missing opening tag: ${result}`);
+	assert.ok(result!.includes("The team will focus on three pillars."), `content missing: ${result}`);
+	assert.ok(result!.includes("</proof-span>"), `missing closing tag: ${result}`);
+	assert.ok(result!.includes('id="p0001"'), `id attr missing: ${result}`);
+	assert.ok(result!.includes('origin="ai"'), `origin attr missing: ${result}`);
+	assert.ok(result!.includes('by="ai:claude"'), `by attr missing: ${result}`);
+});
+
+test("wrapAsProofSpan on heading wraps text after #s", () => {
+	const result = wrapAsProofSpan("## The Section Title", BASE_ATTRS);
+	assert.ok(result !== null);
+	assert.ok(result!.startsWith("## "), `should preserve heading hashes: ${result}`);
+	assert.ok(result!.includes('<proof-span'), `missing proof-span: ${result}`);
+	assert.ok(result!.includes("The Section Title"), `heading text missing: ${result}`);
+	// The ## should be OUTSIDE the span
+	assert.ok(!result!.startsWith("## <proof-span") || result!.startsWith("## <proof-span"),
+		`heading format ok: ${result}`);
+});
+
+test("wrapAsProofSpan on code block returns null", () => {
+	const result = wrapAsProofSpan("```typescript\nconst x = 1;\n```", BASE_ATTRS);
+	assert.equal(result, null, "code block should return null");
+});
+
+test("wrapAsProofSpan on table returns null", () => {
+	const result = wrapAsProofSpan("| A | B |\n|---|---|\n| 1 | 2 |", BASE_ATTRS);
+	assert.equal(result, null, "table should return null");
+});
+
+test("wrapAsProofSpan on hr returns null", () => {
+	const result = wrapAsProofSpan("---", BASE_ATTRS);
+	assert.equal(result, null, "hr should return null");
+});
+
+test("wrapAsProofSpan on blockquote wraps content", () => {
+	const result = wrapAsProofSpan("> This is a quote.", BASE_ATTRS);
+	assert.ok(result !== null);
+	assert.ok(result!.includes(">"), `blockquote prefix missing: ${result}`);
+	assert.ok(result!.includes("This is a quote."), `content missing: ${result}`);
+	assert.ok(result!.includes('<proof-span'), `proof-span missing: ${result}`);
+});
+
+test("wrapAsProofSpan on bullet list wraps each item", () => {
+	const result = wrapAsProofSpan("- item one\n- item two", BASE_ATTRS);
+	assert.ok(result !== null);
+	// Both items should have proof-span wraps
+	const matches = result!.match(/<proof-span/g);
+	assert.ok(matches && matches.length >= 2, `should wrap each item: ${result}`);
+});
+
+test("special chars in basisDetail escaped properly", () => {
+	const attrs: SpanAttrs = {
+		...BASE_ATTRS,
+		basisDetail: 'user said "please fix" this',
+	};
+	const result = wrapAsProofSpan("Some text.", attrs);
+	assert.ok(result !== null);
+	assert.ok(result!.includes("&quot;"), `quotes not escaped: ${result}`);
+	assert.ok(!result!.includes('"please fix"'), `raw quotes should be escaped: ${result}`);
+});
+
+test("unwrapProofSpans removes marks, keeps content", () => {
+	const md = `<proof-span id="p001" origin="ai" by="ai:claude" at="2026-01-01T00:00:00Z">The content.</proof-span>`;
+	const result = unwrapProofSpans(md);
+	assert.equal(result, "The content.");
+});
+
+test("revertProofSpan removes specific span by id", () => {
+	const md = `Before. <proof-span id="p001" origin="ai" by="ai:claude" at="2026-01-01T00:00:00Z">AI text.</proof-span> After.`;
+	const result = revertProofSpan(md, "p001");
+	assert.ok(!result.includes("AI text."), `span content should be removed: ${result}`);
+	assert.ok(result.includes("Before."), `surrounding content preserved: ${result}`);
+	assert.ok(result.includes("After."), `surrounding content preserved: ${result}`);
+});
+
+test("revertProofSpan leaves other spans untouched", () => {
+	const md = `<proof-span id="p001" origin="ai" by="ai:claude" at="2026-01-01T00:00:00Z">First.</proof-span> <proof-span id="p002" origin="ai" by="ai:claude" at="2026-01-01T00:00:00Z">Second.</proof-span>`;
+	const result = revertProofSpan(md, "p001");
+	assert.ok(!result.includes("First."), `first span removed: ${result}`);
+	assert.ok(result.includes("Second."), `second span preserved: ${result}`);
+	assert.ok(result.includes('id="p002"'), `second span tag preserved: ${result}`);
+});

package/.next/standalone/src/tests/proof/rate-limit.test.ts

@@ -0,0 +1,54 @@
+import { test, before } from "node:test";
+import assert from "node:assert/strict";
+import { checkAndConsume, _resetBuckets } from "../../lib/proof/rate-limit.js";
+
+before(() => {
+	_resetBuckets();
+});
+
+test("checkAndConsume: allows up to bucket size ops", () => {
+	_resetBuckets();
+	// Default bucket = 60. Consume 60 one at a time.
+	for (let i = 0; i < 60; i++) {
+		const r = checkAndConsume("ai:unit-test");
+		assert.equal(r.ok, true, `Op ${i + 1} should succeed`);
+	}
+	// 61st should fail
+	const r = checkAndConsume("ai:unit-test");
+	assert.equal(r.ok, false);
+	if (!r.ok) {
+		assert.ok(r.retryAfterMs > 0, "retryAfterMs must be positive");
+	}
+});
+
+test("checkAndConsume: bulk consume fails when n > tokens", () => {
+	_resetBuckets();
+	// Fresh bucket = 60 tokens. Request 61.
+	const r = checkAndConsume("ai:bulk-test", 61);
+	assert.equal(r.ok, false);
+	if (!r.ok) {
+		assert.ok(r.retryAfterMs > 0);
+	}
+});
+
+test("checkAndConsume: different identities have independent buckets", () => {
+	_resetBuckets();
+	// Drain bucket for agent A
+	for (let i = 0; i < 60; i++) {
+		checkAndConsume("ai:agent-a");
+	}
+	// Agent B still has full bucket
+	const r = checkAndConsume("ai:agent-b");
+	assert.equal(r.ok, true, "Agent B must not be affected by agent A draining");
+});
+
+test("checkAndConsume: tokens refill over time", async () => {
+	_resetBuckets();
+	// Drain 3 tokens
+	checkAndConsume("ai:refill-test", 3);
+	// Wait 3 seconds to refill 3 tokens
+	await new Promise((res) => setTimeout(res, 3100));
+	// Should now be able to consume 3 more (57 + 3 = 60 total, or at least 3 refilled)
+	const r = checkAndConsume("ai:refill-test", 3);
+	assert.equal(r.ok, true, "Should have refilled after 3s");
+});