wiki-viewer 1.14.1 → 2.0.0

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

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

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

package/.next/standalone/src/tests/proof/readonly-enforcement.test.ts

@@ -1,161 +0,0 @@
-/**
- * Read-only enforcement: a git-backed (readOnly) workspace must reject write
- * intent at the resolver layer, while reads still pass. Covers both the
- * session resolver (resolveWorkspaceForUser) and the agent resolver
- * (resolveWorkspaceForAgent). Runs in --no-auth mode so no session is needed.
- * Skipped if the git binary is not available.
- */
-import { test, before, after } 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 } from "../../lib/git.js";
-import {
-	createGitWorkspace,
-	createWorkspace,
-	removeWorkspace,
-	sanitizeWorkspace,
-} from "../../lib/workspaces.js";
-import {
-	resolveWorkspaceForUser,
-	resolveWorkspaceForAgent,
-} from "../../lib/workspace-context.js";
-
-const gitEnv = {
-	...process.env,
-	GIT_AUTHOR_NAME: "Test",
-	GIT_AUTHOR_EMAIL: "test@example.com",
-	GIT_COMMITTER_NAME: "Test",
-	GIT_COMMITTER_EMAIL: "test@example.com",
-};
-
-let gitOk = false;
-let tempRoot: string;
-let sourceRepo: string;
-let prevNoAuth: string | undefined;
-
-let roId: string; // read-only git workspace id
-let rwRoot: string; // plain workspace root
-let rwId: string; // plain (writable) workspace id
-
-function reqFor(wsId: string): Request {
-	return new Request(`http://localhost/api/x?ws=${wsId}`);
-}
-
-before(async () => {
-	try {
-		await assertGitAvailable();
-		gitOk = true;
-	} catch {
-		gitOk = false;
-		return;
-	}
-
-	prevNoAuth = process.env.WIKI_NO_AUTH;
-	process.env.WIKI_NO_AUTH = "1";
-
-	tempRoot = await mkdtemp(path.join(tmpdir(), "wiki-ro-"));
-	sourceRepo = path.join(tempRoot, "source");
-	await mkdir(sourceRepo, { recursive: true });
-	execFileSync("git", ["init"], { cwd: sourceRepo, env: gitEnv });
-	execFileSync("git", ["config", "user.email", "test@example.com"], { cwd: sourceRepo, env: gitEnv });
-	execFileSync("git", ["config", "user.name", "Test"], { cwd: sourceRepo, env: gitEnv });
-	await writeFile(path.join(sourceRepo, "README.md"), "# Docs\n");
-	execFileSync("git", ["add", "."], { cwd: sourceRepo, env: gitEnv });
-	execFileSync("git", ["commit", "-m", "init"], { cwd: sourceRepo, env: gitEnv });
-
-	const ro = await createGitWorkspace({ remoteUrl: sourceRepo, name: "ro", allowLocalPath: true });
-	roId = ro.id;
-
-	rwRoot = path.join(tempRoot, "writable");
-	await mkdir(rwRoot, { recursive: true });
-	const rw = await createWorkspace({ rootDir: rwRoot, name: "rw" });
-	rwId = rw.id;
-});
-
-after(async () => {
-	if (gitOk) {
-		await removeWorkspace(roId).catch(() => {});
-		await removeWorkspace(rwId).catch(() => {});
-	}
-	if (prevNoAuth === undefined) delete process.env.WIKI_NO_AUTH;
-	else process.env.WIKI_NO_AUTH = prevNoAuth;
-	if (tempRoot) await rm(tempRoot, { recursive: true, force: true });
-});
-
-test("resolveWorkspaceForUser: write intent on read-only ws -> 403 WORKSPACE_READ_ONLY", async () => {
-	if (!gitOk) return;
-	const res = await resolveWorkspaceForUser(reqFor(roId), "write");
-	assert.equal(res.ok, false);
-	assert.equal(!res.ok && res.status, 403);
-	assert.equal(!res.ok && res.code, "WORKSPACE_READ_ONLY");
-});
-
-test("resolveWorkspaceForUser: read intent on read-only ws -> ok", async () => {
-	if (!gitOk) return;
-	const res = await resolveWorkspaceForUser(reqFor(roId), "read");
-	assert.equal(res.ok, true);
-});
-
-test("resolveWorkspaceForUser: default intent is read (ok on read-only ws)", async () => {
-	if (!gitOk) return;
-	const res = await resolveWorkspaceForUser(reqFor(roId));
-	assert.equal(res.ok, true);
-});
-
-test("resolveWorkspaceForUser: write intent on writable ws -> ok", async () => {
-	if (!gitOk) return;
-	const res = await resolveWorkspaceForUser(reqFor(rwId), "write");
-	assert.equal(res.ok, true);
-});
-
-test("resolveWorkspaceForAgent: write intent on read-only ws -> 403 WORKSPACE_READ_ONLY", async () => {
-	if (!gitOk) return;
-	const res = await resolveWorkspaceForAgent(reqFor(roId), "write");
-	assert.equal(res.ok, false);
-	assert.equal(!res.ok && res.status, 403);
-	assert.equal(!res.ok && res.code, "WORKSPACE_READ_ONLY");
-});
-
-test("resolveWorkspaceForAgent: read intent on read-only ws -> ok", async () => {
-	if (!gitOk) return;
-	const res = await resolveWorkspaceForAgent(reqFor(roId), "read");
-	assert.equal(res.ok, true);
-});
-
-test("resolveWorkspaceForAgent: write intent on writable ws -> ok", async () => {
-	if (!gitOk) return;
-	const res = await resolveWorkspaceForAgent(reqFor(rwId), "write");
-	assert.equal(res.ok, true);
-});
-
-test("sanitizeWorkspace strips git.tokenRef but keeps other metadata", () => {
-	const ws = {
-		id: "ws_test",
-		name: "t",
-		rootDir: "/tmp/x",
-		createdAt: new Date().toISOString(),
-		readOnly: true,
-		git: {
-			remoteUrl: "https://github.com/org/repo.git",
-			branch: "main",
-			tokenRef: "git_secretref",
-			lastSha: "a".repeat(40),
-		},
-	};
-	const safe = sanitizeWorkspace(ws);
-	assert.equal(
-		(safe.git as Record<string, unknown> | undefined)?.tokenRef,
-		undefined,
-		"tokenRef must not survive sanitize",
-	);
-	assert.equal(safe.git?.remoteUrl, "https://github.com/org/repo.git");
-	assert.equal(safe.git?.branch, "main");
-	assert.equal(safe.git?.lastSha, "a".repeat(40));
-	assert.equal(safe.readOnly, true);
-	// Original object must not be mutated.
-	assert.equal(ws.git.tokenRef, "git_secretref");
-});

package/.next/standalone/src/tests/proof/reconcile-sidecar.test.ts

@@ -1,195 +0,0 @@
-/**
- * Tests for the extracted reconcileSidecar function.
- * Verifies: refMap rebuild, revision bump, fingerprint update, event emission,
- * stale-anchor marking on orphaned refs.
- */
-import { test, before, after } from "node:test";
-import assert from "node:assert/strict";
-import { mkdtemp, rm, writeFile } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import { createHash } from "node:crypto";
-import path from "node:path";
-
-import { reconcileSidecar } from "../../lib/proof/ops-applier.js";
-import { emptySidecar, writeSidecar, readSidecar } from "../../lib/proof/sidecar.js";
-
-function sha256(content: string): string {
-	return "sha256:" + createHash("sha256").update(content, "utf8").digest("hex");
-}
-
-let tmpRoot: string;
-
-before(async () => {
-	tmpRoot = await mkdtemp(path.join(tmpdir(), "wiki-reconcile-test-"));
-});
-
-after(async () => {
-	await rm(tmpRoot, { recursive: true, force: true });
-});
-
-test("reconcileSidecar: bumps revision, sets fingerprint, emits file.externallyEdited, writes sidecar", async () => {
-	const mdPath = "notes.md";
-	const absPath = path.join(tmpRoot, mdPath);
-	const content = "# Hello\n\nWorld paragraph.\n";
-	await writeFile(absPath, content, "utf-8");
-
-	const sidecar = emptySidecar(mdPath);
-	sidecar.fingerprint = sha256("old content that changed");
-	const oldRevision = sidecar.revision;
-
-	const fingerprint = sha256(content);
-	const { snapshot, blocks } = await reconcileSidecar({
-		rootDir: tmpRoot,
-		mdPath,
-		content,
-		sidecar,
-		by: "system",
-		eventType: "file.externallyEdited",
-		fingerprint,
-	});
-
-	// Revision bumped
-	assert.equal(sidecar.revision, oldRevision + 1);
-	// Fingerprint updated
-	assert.equal(sidecar.fingerprint, fingerprint);
-	// refMap has entries for the blocks
-	assert.ok(Object.keys(sidecar.refMap).length > 0, "refMap should be non-empty");
-	// Event emitted
-	assert.equal(sidecar.events.length, 1);
-	assert.equal(sidecar.events[0].type, "file.externallyEdited");
-	assert.equal(sidecar.events[0].by, "system");
-	// Sidecar written to disk
-	const onDisk = await readSidecar(tmpRoot, mdPath);
-	assert.ok(onDisk, "sidecar should be written to disk");
-	assert.equal(onDisk!.revision, oldRevision + 1);
-	// Snapshot returned
-	assert.equal(snapshot.path, mdPath);
-	assert.equal(snapshot.revision, oldRevision + 1);
-	assert.equal(snapshot.fingerprint, fingerprint);
-	// Blocks returned
-	assert.ok(blocks.length > 0, "blocks should be non-empty");
-});
-
-test("reconcileSidecar: emits file.rawWritten with oldSha + newSha when eventType is rawWritten", async () => {
-	const mdPath = "raw-notes.md";
-	const absPath = path.join(tmpRoot, mdPath);
-	const content = "# Raw write\n\nNew content.\n";
-	await writeFile(absPath, content, "utf-8");
-
-	const sidecar = emptySidecar(mdPath);
-	const oldSha = sha256("old content");
-	sidecar.fingerprint = oldSha;
-
-	const newSha = sha256(content);
-	await reconcileSidecar({
-		rootDir: tmpRoot,
-		mdPath,
-		content,
-		sidecar,
-		by: "ai:test-agent",
-		eventType: "file.rawWritten",
-		fingerprint: newSha,
-	});
-
-	assert.equal(sidecar.events.length, 1);
-	const ev = sidecar.events[0];
-	assert.equal(ev.type, "file.rawWritten");
-	assert.equal(ev.by, "ai:test-agent");
-	assert.equal(ev.oldSha, oldSha);
-	assert.equal(ev.newSha, newSha);
-});
-
-test("reconcileSidecar: marks pending suggestions stale when ref no longer in new refMap", async () => {
-	const mdPath = "stale-anchors.md";
-	const absPath = path.join(tmpRoot, mdPath);
-
-	// Original content with two paragraphs
-	const original = "# Doc\n\nParagraph one.\n\nParagraph two.\n";
-	await writeFile(absPath, original, "utf-8");
-
-	const sidecar = emptySidecar(mdPath);
-	// Add a pending suggestion referencing a fictional ref that won't exist after reparse
-	sidecar.suggestions.push({
-		id: "s0001",
-		ref: "b_orphan_ref",
-		kind: "replace",
-		status: "pending",
-		by: "ai:test",
-		markdown: "replacement",
-		createdAt: new Date().toISOString(),
-	});
-	// Add a comment referencing a valid ref — will be assigned after reconcile
-	// For simplicity, leave it pointing at another ghost ref too
-	sidecar.comments.push({
-		id: "c0001",
-		ref: "b_also_orphaned",
-		resolved: false,
-		createdAt: new Date().toISOString(),
-		turns: [{ by: "human", text: "comment", at: new Date().toISOString() }],
-	});
-
-	const newContent = "# Doc\n\nTotally new content only.\n";
-	await writeFile(absPath, newContent, "utf-8");
-	const fingerprint = sha256(newContent);
-
-	await reconcileSidecar({
-		rootDir: tmpRoot,
-		mdPath,
-		content: newContent,
-		sidecar,
-		by: "ai:agent",
-		eventType: "file.rawWritten",
-		fingerprint,
-	});
-
-	// Both orphaned anchors should be marked stale
-	const staleSuggestion = sidecar.suggestions.find((s) => s.id === "s0001");
-	assert.equal(staleSuggestion?.stale, true, "suggestion with orphaned ref should be stale");
-
-	const staleComment = sidecar.comments.find((c) => c.id === "c0001");
-	assert.equal(staleComment?.stale, true, "comment with orphaned ref should be stale");
-});
-
-test("reconcileSidecar: does NOT mark resolved comments or non-pending suggestions stale", async () => {
-	const mdPath = "not-stale.md";
-	const absPath = path.join(tmpRoot, mdPath);
-	const content = "# Head\n\nPara.\n";
-	await writeFile(absPath, content, "utf-8");
-
-	const sidecar = emptySidecar(mdPath);
-	// Resolved comment with orphaned ref — should NOT be marked stale
-	sidecar.comments.push({
-		id: "c_resolved",
-		ref: "b_orphan",
-		resolved: true,
-		createdAt: new Date().toISOString(),
-		turns: [],
-	});
-	// Accepted suggestion with orphaned ref — should NOT be marked stale
-	sidecar.archivedSuggestions.push({
-		id: "s_accepted",
-		ref: "b_orphan",
-		kind: "replace",
-		status: "accepted",
-		by: "ai:test",
-		createdAt: new Date().toISOString(),
-	});
-
-	const fingerprint = sha256(content);
-	await reconcileSidecar({
-		rootDir: tmpRoot,
-		mdPath,
-		content,
-		sidecar,
-		by: "system",
-		eventType: "file.externallyEdited",
-		fingerprint,
-	});
-
-	const comment = sidecar.comments.find((c) => c.id === "c_resolved");
-	assert.equal(comment?.stale, undefined, "resolved comment should not be marked stale");
-
-	// archivedSuggestions are not checked by markOrphanedRefsStale
-	const suggestion = sidecar.archivedSuggestions.find((s) => s.id === "s_accepted");
-	assert.equal(suggestion?.stale, undefined, "accepted suggestion should not be marked stale");
-});