wiki-viewer 1.14.1 → 2.0.0

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

@@ -1,82 +0,0 @@
-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

@@ -1,27 +0,0 @@
-/**
- * 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

@@ -1,46 +0,0 @@
-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");
-});

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

@@ -1,368 +0,0 @@
-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

@@ -1,2 +0,0 @@
-// 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

@@ -1,60 +0,0 @@
-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/preload.ts

@@ -1,21 +0,0 @@
-/**
- * Test preload — runs before any test module is imported (via `tsx --import`).
- *
- * auth/server.ts resolves the SQLite DB path from $HOME at module-load time.
- * Several test files import route handlers (and thus auth/server) at the top of
- * the file, before their before() hook can override HOME. Without this preload
- * those imports freeze the DB path to the real ~/.wiki-viewer/auth.db and the
- * suite writes thousands of @test.local users into it.
- *
- * Forcing HOME to a throwaway tmp dir here, before anything else loads,
- * guarantees every test run is isolated from the developer's real config.
- */
-import { mkdtempSync } from "node:fs";
-import { tmpdir } from "node:os";
-import path from "node:path";
-
-if (!process.env.WIKI_TEST_HOME) {
-	const home = mkdtempSync(path.join(tmpdir(), "wiki-test-home-"));
-	process.env.HOME = home;
-	process.env.WIKI_TEST_HOME = home;
-}