@companion-ai/feynman 0.2.0

package/extensions/research-tools/project.ts

@@ -0,0 +1,116 @@
+import { mkdir, stat, writeFile } from "node:fs/promises";
+import { dirname, resolve as resolvePath } from "node:path";
+
+import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import { Type } from "@sinclair/typebox";
+
+import { getExtensionCommandSpec } from "../../metadata/commands.mjs";
+import { renderHtmlPreview, renderPdfPreview, openWithDefaultApp, pathExists, buildProjectAgentsTemplate, buildSessionLogsReadme } from "./preview.js";
+import { formatToolText } from "./shared.js";
+import { searchSessionTranscripts } from "./session-search.js";
+
+export function registerInitCommand(pi: ExtensionAPI): void {
+	pi.registerCommand("init", {
+		description: getExtensionCommandSpec("init")?.description ?? "Initialize AGENTS.md and session-log folders for a research project.",
+		handler: async (_args, ctx) => {
+			const agentsPath = resolvePath(ctx.cwd, "AGENTS.md");
+			const notesDir = resolvePath(ctx.cwd, "notes");
+			const sessionLogsDir = resolvePath(notesDir, "session-logs");
+			const sessionLogsReadmePath = resolvePath(sessionLogsDir, "README.md");
+			const created: string[] = [];
+			const skipped: string[] = [];
+
+			await mkdir(notesDir, { recursive: true });
+			await mkdir(sessionLogsDir, { recursive: true });
+
+			if (!(await pathExists(agentsPath))) {
+				await writeFile(agentsPath, buildProjectAgentsTemplate(), "utf8");
+				created.push("AGENTS.md");
+			} else {
+				skipped.push("AGENTS.md");
+			}
+
+			if (!(await pathExists(sessionLogsReadmePath))) {
+				await writeFile(sessionLogsReadmePath, buildSessionLogsReadme(), "utf8");
+				created.push("notes/session-logs/README.md");
+			} else {
+				skipped.push("notes/session-logs/README.md");
+			}
+
+			const createdSummary = created.length > 0 ? `created: ${created.join(", ")}` : "created: nothing";
+			const skippedSummary = skipped.length > 0 ? `; kept existing: ${skipped.join(", ")}` : "";
+			ctx.ui.notify(`${createdSummary}${skippedSummary}`, "info");
+		},
+	});
+}
+
+export function registerSessionSearchTool(pi: ExtensionAPI): void {
+	pi.registerTool({
+		name: "session_search",
+		label: "Session Search",
+		description: "Search prior Feynman session transcripts to recover what was done, said, or written before.",
+		parameters: Type.Object({
+			query: Type.String({
+				description: "Search query to look for in past sessions.",
+			}),
+			limit: Type.Optional(
+				Type.Number({
+					description: "Maximum number of sessions to return. Defaults to 3.",
+				}),
+			),
+		}),
+		async execute(_toolCallId, params) {
+			const result = await searchSessionTranscripts(params.query, Math.max(1, Math.min(params.limit ?? 3, 8)));
+			return {
+				content: [{ type: "text", text: formatToolText(result) }],
+				details: result,
+			};
+		},
+	});
+}
+
+export function registerPreviewTool(pi: ExtensionAPI): void {
+	pi.registerTool({
+		name: "preview_file",
+		label: "Preview File",
+		description: "Open a markdown, LaTeX, PDF, or code artifact in the browser or a PDF viewer for human review. Rendered HTML/PDF previews are temporary and do not replace the source artifact.",
+		parameters: Type.Object({
+			path: Type.String({
+				description: "Path to the file to preview.",
+			}),
+			target: Type.Optional(
+				Type.String({
+					description: "Preview target: browser or pdf. Defaults to browser.",
+				}),
+			),
+		}),
+		async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
+			const target = (params.target?.trim().toLowerCase() || "browser");
+			if (target !== "browser" && target !== "pdf") {
+				throw new Error("target must be browser or pdf");
+			}
+
+			const resolvedPath = resolvePath(ctx.cwd, params.path);
+			const openedPath =
+				resolvePath(resolvedPath).toLowerCase().endsWith(".pdf") && target === "pdf"
+					? resolvedPath
+					: target === "pdf"
+						? await renderPdfPreview(resolvedPath)
+						: await renderHtmlPreview(resolvedPath);
+
+			await mkdir(dirname(openedPath), { recursive: true }).catch(() => {});
+			await openWithDefaultApp(openedPath);
+
+			const result = {
+				sourcePath: resolvedPath,
+				target,
+				openedPath,
+				temporaryPreview: openedPath !== resolvedPath,
+			};
+			return {
+				content: [{ type: "text", text: formatToolText(result) }],
+				details: result,
+			};
+		},
+	});
+}

package/extensions/research-tools/session-search.ts

@@ -0,0 +1,223 @@
+import { readdir, readFile, stat } from "node:fs/promises";
+import { basename, join } from "node:path";
+import { pathToFileURL } from "node:url";
+
+import { getFeynmanHome } from "./shared.js";
+
+function extractMessageText(message: unknown): string {
+	if (!message || typeof message !== "object") {
+		return "";
+	}
+
+	const content = (message as { content?: unknown }).content;
+	if (typeof content === "string") {
+		return content;
+	}
+	if (!Array.isArray(content)) {
+		return "";
+	}
+
+	return content
+		.map((item) => {
+			if (!item || typeof item !== "object") {
+				return "";
+			}
+			const record = item as { type?: string; text?: unknown; arguments?: unknown; name?: unknown };
+			if (record.type === "text" && typeof record.text === "string") {
+				return record.text;
+			}
+			if (record.type === "toolCall") {
+				const name = typeof record.name === "string" ? record.name : "tool";
+				const args =
+					typeof record.arguments === "string"
+						? record.arguments
+						: record.arguments
+							? JSON.stringify(record.arguments)
+							: "";
+				return `[tool:${name}] ${args}`;
+			}
+			return "";
+		})
+		.filter(Boolean)
+		.join("\n");
+}
+
+function buildExcerpt(text: string, query: string, radius = 180): string {
+	const normalizedText = text.replace(/\s+/g, " ").trim();
+	if (!normalizedText) {
+		return "";
+	}
+
+	const lower = normalizedText.toLowerCase();
+	const q = query.toLowerCase();
+	const index = lower.indexOf(q);
+	if (index === -1) {
+		return normalizedText.slice(0, radius * 2) + (normalizedText.length > radius * 2 ? "..." : "");
+	}
+
+	const start = Math.max(0, index - radius);
+	const end = Math.min(normalizedText.length, index + q.length + radius);
+	const prefix = start > 0 ? "..." : "";
+	const suffix = end < normalizedText.length ? "..." : "";
+	return `${prefix}${normalizedText.slice(start, end)}${suffix}`;
+}
+
+export async function searchSessionTranscripts(query: string, limit: number): Promise<{
+	query: string;
+	results: Array<{
+		sessionId: string;
+		sessionFile: string;
+		startedAt?: string;
+		cwd?: string;
+		matchCount: number;
+		topMatches: Array<{ role: string; timestamp?: string; excerpt: string }>;
+	}>;
+}> {
+	const packageRoot = process.env.FEYNMAN_PI_NPM_ROOT;
+	if (packageRoot) {
+		try {
+			const indexerPath = pathToFileURL(
+				join(packageRoot, "@kaiserlich-dev", "pi-session-search", "extensions", "indexer.ts"),
+			).href;
+			const indexer = await import(indexerPath) as {
+				updateIndex?: (onProgress?: (msg: string) => void) => Promise<number>;
+				search?: (query: string, limit?: number) => Array<{
+					sessionPath: string;
+					project: string;
+					timestamp: string;
+					snippet: string;
+					rank: number;
+					title: string | null;
+				}>;
+				getSessionSnippets?: (sessionPath: string, query: string, limit?: number) => string[];
+			};
+
+			await indexer.updateIndex?.();
+			const results = indexer.search?.(query, limit) ?? [];
+			if (results.length > 0) {
+				return {
+					query,
+					results: results.map((result) => ({
+						sessionId: basename(result.sessionPath),
+						sessionFile: result.sessionPath,
+						startedAt: result.timestamp,
+						cwd: result.project,
+						matchCount: 1,
+						topMatches: (indexer.getSessionSnippets?.(result.sessionPath, query, 4) ?? [result.snippet])
+							.filter(Boolean)
+							.map((excerpt) => ({
+								role: "match",
+								excerpt,
+							})),
+					})),
+				};
+			}
+		} catch {
+			// Fall back to direct JSONL scanning below.
+		}
+	}
+
+	const sessionDir = join(getFeynmanHome(), "sessions");
+	const terms = query
+		.toLowerCase()
+		.split(/\s+/)
+		.map((term) => term.trim())
+		.filter((term) => term.length >= 2);
+	const needle = query.toLowerCase();
+
+	let files: string[] = [];
+	try {
+		files = (await readdir(sessionDir))
+			.filter((entry) => entry.endsWith(".jsonl"))
+			.map((entry) => join(sessionDir, entry));
+	} catch {
+		return { query, results: [] };
+	}
+
+	const sessions = [];
+	for (const file of files) {
+		const raw = await readFile(file, "utf8").catch(() => "");
+		if (!raw) {
+			continue;
+		}
+
+		let sessionId = basename(file);
+		let startedAt: string | undefined;
+		let cwd: string | undefined;
+		const matches: Array<{ role: string; timestamp?: string; excerpt: string }> = [];
+
+		for (const line of raw.split("\n")) {
+			if (!line.trim()) {
+				continue;
+			}
+			try {
+				const record = JSON.parse(line) as {
+					type?: string;
+					id?: string;
+					timestamp?: string;
+					cwd?: string;
+					message?: { role?: string; content?: unknown };
+				};
+				if (record.type === "session") {
+					sessionId = record.id ?? sessionId;
+					startedAt = record.timestamp;
+					cwd = record.cwd;
+					continue;
+				}
+				if (record.type !== "message" || !record.message) {
+					continue;
+				}
+
+				const text = extractMessageText(record.message);
+				if (!text) {
+					continue;
+				}
+				const lower = text.toLowerCase();
+				const matched = lower.includes(needle) || terms.some((term) => lower.includes(term));
+				if (!matched) {
+					continue;
+				}
+				matches.push({
+					role: record.message.role ?? "unknown",
+					timestamp: record.timestamp,
+					excerpt: buildExcerpt(text, query),
+				});
+			} catch {
+				continue;
+			}
+		}
+
+		if (matches.length === 0) {
+			continue;
+		}
+
+		let mtime = 0;
+		try {
+			mtime = (await stat(file)).mtimeMs;
+		} catch {
+			mtime = 0;
+		}
+
+		sessions.push({
+			sessionId,
+			sessionFile: file,
+			startedAt,
+			cwd,
+			matchCount: matches.length,
+			topMatches: matches.slice(0, 4),
+			mtime,
+		});
+	}
+
+	sessions.sort((a, b) => {
+		if (b.matchCount !== a.matchCount) {
+			return b.matchCount - a.matchCount;
+		}
+		return b.mtime - a.mtime;
+	});
+
+	return {
+		query,
+		results: sessions.slice(0, limit).map(({ mtime: _mtime, ...session }) => session),
+	};
+}

package/extensions/research-tools/shared.ts

@@ -0,0 +1,46 @@
+import { readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, resolve as resolvePath } from "node:path";
+import { fileURLToPath } from "node:url";
+
+export const APP_ROOT = resolvePath(dirname(fileURLToPath(import.meta.url)), "..", "..");
+
+export const FEYNMAN_VERSION = (() => {
+	try {
+		const pkg = JSON.parse(readFileSync(resolvePath(APP_ROOT, "package.json"), "utf8")) as { version?: string };
+		return pkg.version ?? "dev";
+	} catch {
+		return "dev";
+	}
+})();
+
+export const FEYNMAN_AGENT_LOGO = [
+	"███████╗███████╗██╗   ██╗███╗   ██╗███╗   ███╗ █████╗ ███╗   ██╗",
+	"██╔════╝██╔════╝╚██╗ ██╔╝████╗  ██║████╗ ████║██╔══██╗████╗  ██║",
+	"█████╗  █████╗   ╚████╔╝ ██╔██╗ ██║██╔████╔██║███████║██╔██╗ ██║",
+	"██╔══╝  ██╔══╝    ╚██╔╝  ██║╚██╗██║██║╚██╔╝██║██╔══██║██║╚██╗██║",
+	"██║     ███████╗   ██║   ██║ ╚████║██║ ╚═╝ ██║██║  ██║██║ ╚████║",
+	"╚═╝     ╚══════╝   ╚═╝   ╚═╝  ╚═══╝╚═╝     ╚═╝╚═╝  ╚═╝╚═╝  ╚═══╝",
+];
+
+export const FEYNMAN_RESEARCH_TOOLS = [
+	"alpha_search",
+	"alpha_get_paper",
+	"alpha_ask_paper",
+	"alpha_annotate_paper",
+	"alpha_list_annotations",
+	"alpha_read_code",
+	"session_search",
+	"preview_file",
+];
+
+export function formatToolText(result: unknown): string {
+	return typeof result === "string" ? result : JSON.stringify(result, null, 2);
+}
+
+export function getFeynmanHome(): string {
+	const agentDir = process.env.FEYNMAN_CODING_AGENT_DIR ??
+		process.env.PI_CODING_AGENT_DIR ??
+		resolvePath(homedir(), ".feynman", "agent");
+	return dirname(agentDir);
+}

package/extensions/research-tools.ts

@@ -0,0 +1,25 @@
+import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+
+import { registerAlphaCommands, registerAlphaTools } from "./research-tools/alpha.js";
+import { installFeynmanHeader } from "./research-tools/header.js";
+import { registerHelpCommand } from "./research-tools/help.js";
+import { registerInitCommand, registerPreviewTool, registerSessionSearchTool } from "./research-tools/project.js";
+
+export default function researchTools(pi: ExtensionAPI): void {
+	const cache: { agentSummaryPromise?: Promise<{ agents: string[]; chains: string[] }> } = {};
+
+	pi.on("session_start", async (_event, ctx) => {
+		await installFeynmanHeader(pi, ctx, cache);
+	});
+
+	pi.on("session_switch", async (_event, ctx) => {
+		await installFeynmanHeader(pi, ctx, cache);
+	});
+
+	registerAlphaCommands(pi);
+	registerHelpCommand(pi);
+	registerInitCommand(pi);
+	registerSessionSearchTool(pi);
+	registerAlphaTools(pi);
+	registerPreviewTool(pi);
+}

package/metadata/commands.d.mts

@@ -0,0 +1,46 @@
+export type PromptSpec = {
+	name: string;
+	description: string;
+	args: string;
+	section: string;
+	topLevelCli: boolean;
+};
+
+export type ExtensionCommandSpec = {
+	name: string;
+	args: string;
+	section: string;
+	description: string;
+	publicDocs: boolean;
+};
+
+export type LivePackageCommandSpec = {
+	name: string;
+	usage: string;
+};
+
+export type LivePackageCommandGroup = {
+	title: string;
+	commands: LivePackageCommandSpec[];
+};
+
+export type CliCommand = {
+	usage: string;
+	description: string;
+};
+
+export type CliCommandSection = {
+	title: string;
+	commands: CliCommand[];
+};
+
+export declare function readPromptSpecs(appRoot: string): PromptSpec[];
+export declare const extensionCommandSpecs: ExtensionCommandSpec[];
+export declare const livePackageCommandGroups: LivePackageCommandGroup[];
+export declare const cliCommandSections: CliCommandSection[];
+export declare const legacyFlags: CliCommand[];
+export declare const topLevelCommandNames: string[];
+
+export declare function formatSlashUsage(command: { name: string; args?: string }): string;
+export declare function formatCliWorkflowUsage(command: { name: string; args?: string }): string;
+export declare function getExtensionCommandSpec(name: string): ExtensionCommandSpec | undefined;

package/metadata/commands.mjs

@@ -0,0 +1,133 @@
+import { readFileSync, readdirSync } from "node:fs";
+import { resolve } from "node:path";
+
+function parseFrontmatter(text) {
+	const match = text.match(/^---\n([\s\S]*?)\n---\n?/);
+	if (!match) return {};
+
+	const frontmatter = {};
+	for (const line of match[1].split("\n")) {
+		const separator = line.indexOf(":");
+		if (separator === -1) continue;
+		const key = line.slice(0, separator).trim();
+		const value = line.slice(separator + 1).trim();
+		if (!key) continue;
+		frontmatter[key] = value;
+	}
+	return frontmatter;
+}
+
+export function readPromptSpecs(appRoot) {
+	const dir = resolve(appRoot, "prompts");
+	return readdirSync(dir)
+		.filter((f) => f.endsWith(".md"))
+		.map((f) => {
+			const text = readFileSync(resolve(dir, f), "utf8");
+			const fm = parseFrontmatter(text);
+			return {
+				name: f.replace(/\.md$/, ""),
+				description: fm.description ?? "",
+				args: fm.args ?? "",
+				section: fm.section ?? "Research Workflows",
+				topLevelCli: fm.topLevelCli === "true",
+			};
+		});
+}
+
+export const extensionCommandSpecs = [
+	{ name: "help", args: "", section: "Project & Session", description: "Show grouped Feynman commands and prefill the editor with a selected command.", publicDocs: true },
+	{ name: "init", args: "", section: "Project & Session", description: "Bootstrap AGENTS.md and session-log folders for a research project.", publicDocs: true },
+	{ name: "alpha-login", args: "", section: "Setup", description: "Sign in to alphaXiv from inside Feynman.", publicDocs: true },
+	{ name: "alpha-status", args: "", section: "Setup", description: "Show alphaXiv authentication status.", publicDocs: true },
+	{ name: "alpha-logout", args: "", section: "Setup", description: "Clear alphaXiv auth from inside Feynman.", publicDocs: true },
+];
+
+export const livePackageCommandGroups = [
+	{
+		title: "Agents & Delegation",
+		commands: [
+			{ name: "agents", usage: "/agents" },
+			{ name: "run", usage: "/run <agent> <task>" },
+			{ name: "chain", usage: "/chain agent1 -> agent2" },
+			{ name: "parallel", usage: "/parallel agent1 -> agent2" },
+		],
+	},
+	{
+		title: "Bundled Package Commands",
+		commands: [
+			{ name: "ps", usage: "/ps" },
+			{ name: "schedule-prompt", usage: "/schedule-prompt" },
+			{ name: "search", usage: "/search" },
+			{ name: "preview", usage: "/preview" },
+			{ name: "new", usage: "/new" },
+			{ name: "quit", usage: "/quit" },
+			{ name: "exit", usage: "/exit" },
+		],
+	},
+];
+
+export const cliCommandSections = [
+	{
+		title: "Core",
+		commands: [
+			{ usage: "feynman", description: "Launch the interactive REPL." },
+			{ usage: "feynman chat [prompt]", description: "Start chat explicitly, optionally with an initial prompt." },
+			{ usage: "feynman help", description: "Show CLI help." },
+			{ usage: "feynman setup", description: "Run the guided setup wizard." },
+			{ usage: "feynman doctor", description: "Diagnose config, auth, Pi runtime, and preview dependencies." },
+			{ usage: "feynman status", description: "Show the current setup summary." },
+		],
+	},
+	{
+		title: "Model Management",
+		commands: [
+			{ usage: "feynman model list", description: "List available models in Pi auth storage." },
+			{ usage: "feynman model login [id]", description: "Login to a Pi OAuth model provider." },
+			{ usage: "feynman model logout [id]", description: "Logout from a Pi OAuth model provider." },
+			{ usage: "feynman model set <provider/model>", description: "Set the default model." },
+		],
+	},
+	{
+		title: "AlphaXiv",
+		commands: [
+			{ usage: "feynman alpha login", description: "Sign in to alphaXiv." },
+			{ usage: "feynman alpha logout", description: "Clear alphaXiv auth." },
+			{ usage: "feynman alpha status", description: "Check alphaXiv auth status." },
+		],
+	},
+	{
+		title: "Utilities",
+		commands: [
+			{ usage: "feynman search status", description: "Show Pi web-access status and config path." },
+			{ usage: "feynman update [package]", description: "Update installed packages, or a specific package." },
+		],
+	},
+];
+
+export const legacyFlags = [
+	{ usage: '--prompt "<text>"', description: "Run one prompt and exit." },
+	{ usage: "--alpha-login", description: "Sign in to alphaXiv and exit." },
+	{ usage: "--alpha-logout", description: "Clear alphaXiv auth and exit." },
+	{ usage: "--alpha-status", description: "Show alphaXiv auth status and exit." },
+	{ usage: "--model <provider:model>", description: "Force a specific model." },
+	{ usage: "--thinking <level>", description: "Set thinking level: off | minimal | low | medium | high | xhigh." },
+	{ usage: "--cwd <path>", description: "Set the working directory for tools." },
+	{ usage: "--session-dir <path>", description: "Set the session storage directory." },
+	{ usage: "--new-session", description: "Start a new persisted session." },
+	{ usage: "--doctor", description: "Alias for `feynman doctor`." },
+	{ usage: "--setup-preview", description: "Alias for `feynman setup preview`." },
+];
+
+export const topLevelCommandNames = ["alpha", "chat", "doctor", "help", "model", "search", "setup", "status", "update"];
+
+export function formatSlashUsage(command) {
+	return `/${command.name}${command.args ? ` ${command.args}` : ""}`;
+}
+
+export function formatCliWorkflowUsage(command) {
+	return `feynman ${command.name}${command.args ? ` ${command.args}` : ""}`;
+}
+
+export function getExtensionCommandSpec(name) {
+	return extensionCommandSpecs.find((command) => command.name === name);
+}

package/package.json

@@ -0,0 +1,71 @@
+{
+  "name": "@companion-ai/feynman",
+  "version": "0.2.0",
+  "description": "Research-first CLI agent built on Pi and alphaXiv",
+  "type": "module",
+  "bin": {
+    "feynman": "./bin/feynman.js"
+  },
+  "files": [
+    "bin/",
+    "dist/",
+    "metadata/",
+    ".feynman/agents/",
+    ".feynman/settings.json",
+    ".feynman/SYSTEM.md",
+    ".feynman/themes/",
+    "extensions/",
+    "prompts/",
+    "scripts/",
+    "skills/",
+    "AGENTS.md",
+    "README.md",
+    ".env.example"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json",
+    "dev": "tsx src/index.ts",
+    "postinstall": "node ./scripts/patch-embedded-pi.mjs",
+    "start": "tsx src/index.ts",
+    "start:dist": "node ./bin/feynman.js",
+    "test": "node --import tsx --test --test-concurrency=1 tests/*.test.ts",
+    "typecheck": "tsc --noEmit"
+  },
+  "keywords": [
+    "pi-package",
+    "research-agent",
+    "literature-review",
+    "experiments"
+  ],
+  "pi": {
+    "extensions": [
+      "./extensions"
+    ],
+    "prompts": [
+      "./prompts"
+    ]
+  },
+  "dependencies": {
+    "@companion-ai/alpha-hub": "^0.1.2",
+    "@mariozechner/pi-ai": "^0.62.0",
+    "@mariozechner/pi-coding-agent": "^0.62.0",
+    "@sinclair/typebox": "^0.34.48",
+    "dotenv": "^17.3.1"
+  },
+  "devDependencies": {
+    "@types/node": "^25.5.0",
+    "tsx": "^4.21.0",
+    "typescript": "^5.9.3"
+  },
+  "engines": {
+    "node": ">=20.18.1"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/getcompanion-ai/feynman.git"
+  },
+  "homepage": "https://github.com/getcompanion-ai/feynman#readme",
+  "bugs": {
+    "url": "https://github.com/getcompanion-ai/feynman/issues"
+  }
+}

package/prompts/audit.md

@@ -0,0 +1,15 @@
+---
+description: Compare a paper's claims against its public codebase and identify mismatches, omissions, and reproducibility risks.
+args: <item>
+section: Research Workflows
+topLevelCli: true
+---
+Audit the paper and codebase for: $@
+
+Requirements:
+- Before starting, outline the audit plan: which paper, which repo, which claims to check. Present the plan to the user and confirm before proceeding.
+- Use the `researcher` subagent for evidence gathering and the `verifier` subagent to verify sources and add inline citations when the audit is non-trivial.
+- Compare claimed methods, defaults, metrics, and data handling against the actual code.
+- Call out missing code, mismatches, ambiguous defaults, and reproduction risks.
+- Save exactly one audit artifact to `outputs/` as markdown.
+- End with a `Sources` section containing paper and repository URLs.