wiki-viewer 1.14.1 → 1.14.2

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

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

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

@@ -1,80 +0,0 @@
-/**
- * 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/git-branches-checkout.test.ts

@@ -1,136 +0,0 @@
-/**
- * Focused tests for gitBranches and gitCheckout lib functions.
- * Skips silently if git binary is not available.
- */
-import { test, before, after, describe } from "node:test";
-import assert from "node:assert/strict";
-import { mkdtemp, rm, writeFile, mkdir } from "node:fs/promises";
-import { execFileSync } from "node:child_process";
-import { tmpdir } from "node:os";
-import path from "node:path";
-
-import {
-	assertGitAvailable,
-	gitBranches,
-	gitCheckout,
-} from "../../lib/git.js";
-
-const gitEnv = {
-	...process.env,
-	GIT_AUTHOR_NAME: "Test User",
-	GIT_AUTHOR_EMAIL: "test@example.com",
-	GIT_COMMITTER_NAME: "Test User",
-	GIT_COMMITTER_EMAIL: "test@example.com",
-};
-
-let gitOk = false;
-let tempRoot: string;
-let repoDir: string;
-let featureBranch: string;
-
-before(async () => {
-	try {
-		await assertGitAvailable();
-		gitOk = true;
-	} catch {
-		return;
-	}
-
-	tempRoot = await mkdtemp(path.join(tmpdir(), "wiki-branches-ck-"));
-	repoDir = path.join(tempRoot, "repo");
-	await mkdir(repoDir, { recursive: true });
-
-	execFileSync("git", ["init"], { cwd: repoDir, env: gitEnv });
-	execFileSync("git", ["config", "user.email", "test@example.com"], { cwd: repoDir, env: gitEnv });
-	execFileSync("git", ["config", "user.name", "Test User"], { cwd: repoDir, env: gitEnv });
-
-	await writeFile(path.join(repoDir, "README.md"), "# Hello\n");
-	execFileSync("git", ["add", "."], { cwd: repoDir, env: gitEnv });
-	execFileSync("git", ["commit", "-m", "Initial commit"], { cwd: repoDir, env: gitEnv });
-
-	// Create a second branch for checkout tests
-	featureBranch = "feature-branch-test";
-	execFileSync("git", ["checkout", "-b", featureBranch], { cwd: repoDir, env: gitEnv });
-	// Switch back to main/master so we can checkout feature-branch-test
-	execFileSync("git", ["checkout", "-"], { cwd: repoDir, env: gitEnv });
-});
-
-after(async () => {
-	if (tempRoot) await rm(tempRoot, { recursive: true, force: true });
-});
-
-// ---------------------------------------------------------------------------
-// gitBranches
-// ---------------------------------------------------------------------------
-
-describe("gitBranches", () => {
-	test("returns array with at least one branch", async () => {
-		if (!gitOk) return;
-		const branches = await gitBranches(repoDir);
-		assert.ok(Array.isArray(branches));
-		assert.ok(branches.length >= 1, `expected branches, got ${JSON.stringify(branches)}`);
-	});
-
-	test("marks exactly one branch as current", async () => {
-		if (!gitOk) return;
-		const branches = await gitBranches(repoDir);
-		const current = branches.filter((b) => b.current);
-		assert.equal(current.length, 1, "exactly one branch should be current");
-		assert.ok(current[0].name.length > 0, "current branch has non-empty name");
-	});
-
-	test("lists all local branches including feature branch", async () => {
-		if (!gitOk) return;
-		const branches = await gitBranches(repoDir);
-		const names = branches.map((b) => b.name);
-		assert.ok(names.includes(featureBranch), `expected ${featureBranch} in ${JSON.stringify(names)}`);
-	});
-});
-
-// ---------------------------------------------------------------------------
-// gitCheckout
-// ---------------------------------------------------------------------------
-
-describe("gitCheckout", () => {
-	test("throws with invalidBranch=true for invalid branch name format", async () => {
-		if (!gitOk) return;
-		const err = await gitCheckout(repoDir, "../../evil").catch((e) => e);
-		assert.ok(err instanceof Error, "should throw Error");
-		assert.equal((err as Error & { invalidBranch?: boolean }).invalidBranch, true);
-	});
-
-	test("throws with invalidBranch=true for branch name with semicolon", async () => {
-		if (!gitOk) return;
-		const err = await gitCheckout(repoDir, "main;evil").catch((e) => e);
-		assert.ok(err instanceof Error, "should throw Error");
-		assert.equal((err as Error & { invalidBranch?: boolean }).invalidBranch, true);
-	});
-
-	test("succeeds on clean repo when checking out existing branch", async () => {
-		if (!gitOk) return;
-		const result = await gitCheckout(repoDir, featureBranch);
-		assert.equal(result.branch, featureBranch);
-		assert.match(result.sha, /^[0-9a-f]{40}$/);
-		// Switch back
-		execFileSync("git", ["checkout", "-"], { cwd: repoDir, env: gitEnv });
-	});
-
-	test("throws with dirty=true when working tree has uncommitted changes", async () => {
-		if (!gitOk) return;
-		// Create an untracked file to make repo dirty
-		await writeFile(path.join(repoDir, "untracked.txt"), "dirty\n");
-		// Stage it to make it appear in porcelain status
-		execFileSync("git", ["add", "untracked.txt"], { cwd: repoDir, env: gitEnv });
-
-		try {
-			const err = await gitCheckout(repoDir, featureBranch).catch((e) => e);
-			assert.ok(err instanceof Error, "should throw Error");
-			assert.equal((err as Error & { dirty?: boolean }).dirty, true);
-		} finally {
-			// Clean up the staged file
-			execFileSync("git", ["restore", "--staged", "untracked.txt"], { cwd: repoDir, env: gitEnv });
-			const { rm: rmFile } = await import("node:fs/promises");
-			await rmFile(path.join(repoDir, "untracked.txt"));
-		}
-	});
-});