second-read 0.0.0-stage → 0.1.0

package/dist/claude.js

@@ -0,0 +1,422 @@
+// What a Claude Code tool call would post: the text of gh and git commands run through Bash, and the text of a
+// GitHub tool from an MCP server.
+import { readFileSync } from "node:fs";
+import { basename, resolve } from "node:path";
+import { KIND_NAMES } from "./checks.js";
+import { parseGh, postTexts } from "./gh.js";
+import { output, parseShell, UNKNOWN, UNKNOWN_END, unknown } from "./shell.js";
+// The texts each command in a Bash tool call would post, read against the folder each one runs in.
+export function bashPosts(command, cwd, home) {
+    return scriptPosts(command, cwd, home, new Map());
+}
+function scriptPosts(script, cwd, home, written) {
+    const posts = [];
+    let dir = cwd;
+    for (const command of parseShell(script)) {
+        const words = unwrap(command.words);
+        const name = basename(words[0] ?? "").replace(/\.exe$/i, "");
+        const args = words.slice(1);
+        const { stdin } = command;
+        if (name === "cd" || name === "pushd") {
+            const target = args.find((a) => !a.startsWith("-") || a === "-");
+            if (target === undefined)
+                dir = home;
+            else if (target !== "-" && !target.includes(UNKNOWN))
+                dir = resolve(dir, target.replace(/^~(?=\/|$)/, home));
+        }
+        else if (/^(ba|z|da|k)?sh$/.test(name) && args[0] === "-c" && args[1] !== undefined) {
+            if (!args[1].includes(UNKNOWN))
+                posts.push(...scriptPosts(args[1], dir, home, written));
+        }
+        else if (name === "eval") {
+            const script = args.join(" ");
+            if (!script.includes(UNKNOWN))
+                posts.push(...scriptPosts(script, dir, home, written));
+        }
+        else if (name === "gh") {
+            posts.push(...ghPosts(args, stdin, dir, written));
+        }
+        else if (name === "git") {
+            posts.push(...gitPosts(args, stdin, dir, written));
+        }
+        const printed = output({ ...command, words });
+        const files = (command.writes ?? []).map((w) => ({ ...w, by: "this command" }));
+        if (name === "tee") {
+            const append = args.some((a) => /^-[^-]*a/.test(a) || a === "--append");
+            for (const file of args.filter((a) => !a.startsWith("-")))
+                files.push({ file, append, by: "tee" });
+        }
+        for (const { file, append } of files) {
+            if (file.includes(UNKNOWN))
+                continue;
+            const path = resolve(dir, file);
+            written.set(path, printed !== undefined && !append ? printed : unknown(`what ${words.join(" ")} writes to ${file}`));
+        }
+    }
+    return posts;
+}
+// The command itself, past variable assignments and commands that run the one after them.
+function unwrap(words) {
+    let i = 0;
+    for (;;) {
+        while (i < words.length && /^[A-Za-z_][A-Za-z0-9_]*=/.test(words[i]))
+            i++;
+        const name = words[i];
+        if (name === "env") {
+            for (i++; i < words.length && (words[i].startsWith("-") || /^[A-Za-z_][A-Za-z0-9_]*=/.test(words[i])); i++) {
+                if (/^(-u|--unset|-C|--chdir)$/.test(words[i]))
+                    i++;
+            }
+        }
+        else if (name === "command" || name === "exec" || name === "nohup" || name === "time" || name === "builtin") {
+            i++;
+            while (i < words.length && words[i].startsWith("-"))
+                i++;
+        }
+        else if (name === "sudo") {
+            i = pastOptions(words, i + 1, "ugChpUTrtDR");
+        }
+        else if (name === "xargs") {
+            // xargs adds arguments from its input, so the command's text is filled in only when it runs.
+            let replace;
+            i = pastOptions(words, i + 1, "adEILnPs", "eil", (flag, value) => {
+                if (flag === "I")
+                    replace = value;
+                if (flag === "i" || flag === "--replace")
+                    replace = value || "{}";
+            });
+            const added = unknown("the arguments xargs adds");
+            const rest = words.slice(i);
+            if (replace === undefined)
+                return [...rest, added];
+            return rest.map((w) => (w.includes(replace) ? w.split(replace).join(added) : w));
+        }
+        else {
+            return words.slice(i);
+        }
+    }
+}
+// The index past a command's options, as in `sudo -u someone`. `valued` names the short options that take a value,
+// and `joined` those that take one only when it's joined on, as in xargs -i{}.
+function pastOptions(words, start, valued, joined = "", seen = () => { }) {
+    let i = start;
+    for (; i < words.length && words[i].startsWith("-"); i++) {
+        const word = words[i];
+        if (word === "--")
+            return i + 1;
+        if (word.startsWith("--")) {
+            const eq = word.indexOf("=");
+            seen(eq < 0 ? word : word.slice(0, eq), eq < 0 ? "" : word.slice(eq + 1));
+            continue;
+        }
+        for (let j = 1; j < word.length; j++) {
+            const flag = word[j];
+            if (!valued.includes(flag)) {
+                if (joined.includes(flag) && j + 1 < word.length) {
+                    seen(flag, word.slice(j + 1));
+                    break;
+                }
+                seen(flag, "");
+                continue;
+            }
+            const value = j + 1 < word.length ? word.slice(j + 1) : (words[++i] ?? "");
+            seen(flag, value);
+            break;
+        }
+    }
+    return i;
+}
+// A file's text, or stdin's for "-". A name the shell fills in is kept as the text, so it's refused unread.
+function reader(stdin, dir, written) {
+    const load = (file) => {
+        if (file.includes(UNKNOWN))
+            return file;
+        const path = resolve(dir, file);
+        return written.get(path) ?? readFileSync(path, "utf8");
+    };
+    return (file) => {
+        if (file !== "-")
+            return load(file);
+        if (stdin === undefined)
+            return "";
+        return "text" in stdin ? stdin.text : load(stdin.file);
+    };
+}
+function ghPosts(args, stdin, dir, written) {
+    if (args[0] === "api")
+        return ghApiPosts(args.slice(1), reader(stdin, dir, written), dir);
+    const post = parseGh(args);
+    if (!post)
+        return [];
+    return postTexts(post, reader(stdin, dir, written)).map(([where, text]) => ({ where, kind: post.kind, text, cwd: dir }));
+}
+const GH_API_VALUE_FLAGS = new Set(["-X", "--method", "-f", "--raw-field", "-F", "--field", "-H", "--header", "-q",
+    "--jq", "-t", "--template", "-p", "--preview", "--hostname", "--cache", "--input"]);
+// gh api sends its fields, or the --input file, and switches to POST when it has either. A GraphQL query that
+// isn't a mutation only reads.
+function ghApiPosts(args, read, dir) {
+    let endpoint;
+    let method;
+    let input;
+    const fields = [];
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        let name;
+        let value;
+        if (arg.startsWith("--")) {
+            const eq = arg.indexOf("=");
+            name = eq < 0 ? arg : arg.slice(0, eq);
+            if (eq >= 0)
+                value = arg.slice(eq + 1);
+        }
+        else if (arg.startsWith("-") && arg.length > 1) {
+            name = arg.slice(0, 2);
+            if (arg.length > 2)
+                value = arg.slice(arg[2] === "=" ? 3 : 2);
+        }
+        else {
+            endpoint ??= arg;
+            continue;
+        }
+        if (!GH_API_VALUE_FLAGS.has(name))
+            continue;
+        if (value === undefined)
+            value = args[++i];
+        if (value === undefined)
+            continue;
+        if (name === "-X" || name === "--method")
+            method = value.toUpperCase();
+        else if (name === "--input")
+            input = value;
+        else if (name === "-f" || name === "--raw-field")
+            fields.push({ field: value, typed: false });
+        else if (name === "-F" || name === "--field")
+            fields.push({ field: value, typed: true });
+    }
+    method ??= fields.length > 0 || input !== undefined ? "POST" : "GET";
+    if (method === "GET" || method === "HEAD")
+        return [];
+    const target = `gh api ${endpoint ?? ""}`.trim();
+    const kind = apiKind(endpoint ?? "");
+    const texts = [];
+    for (const { field, typed } of fields) {
+        const eq = field.indexOf("=");
+        const key = eq < 0 ? field : field.slice(0, eq);
+        if (eq < 0 || DESTINATION_KEYS.has(key))
+            continue;
+        const value = field.slice(eq + 1);
+        texts.push([`the ${key} field of ${target}`, typed && value.startsWith("@") ? read(value.slice(1)) : value]);
+    }
+    if (endpoint === "graphql") {
+        const query = texts.find(([where]) => where.startsWith("the query field"))?.[1];
+        if (query !== undefined && !query.includes(UNKNOWN) && !/\bmutation\b/.test(query))
+            return [];
+    }
+    if (input !== undefined) {
+        const text = read(input);
+        const where = input === "-" ? `the body of ${target}` : `the body of ${target}, from ${input}`;
+        let json;
+        try {
+            json = JSON.parse(text);
+        }
+        catch {
+            texts.push([where, text]);
+        }
+        if (json !== undefined)
+            for (const [path, leaf] of leaves(json))
+                texts.push([`${path} in ${where}`, leaf]);
+    }
+    return texts.map(([where, text]) => ({ where, kind, text, cwd: dir }));
+}
+function apiKind(endpoint) {
+    if (/comments/.test(endpoint))
+        return "comment";
+    if (/reviews/.test(endpoint))
+        return "review";
+    if (/pulls/.test(endpoint))
+        return "pr";
+    if (/issues/.test(endpoint))
+        return "issue";
+    if (/commits|git\/|contents/.test(endpoint))
+        return "commit";
+    return "comment";
+}
+const COMMIT = {
+    where: KIND_NAMES.commit,
+    short: "mFCct",
+    joined: "Su",
+    long: {
+        "--message": "message",
+        "--file": "file",
+        "--trailer": "trailer",
+        "--author": "value",
+        "--date": "value",
+        "--reuse-message": "value",
+        "--reedit-message": "value",
+        "--fixup": "value",
+        "--squash": "value",
+        "--template": "value",
+        "--cleanup": "value",
+        "--pathspec-from-file": "value",
+    },
+};
+const TAG = {
+    where: "this tag message",
+    short: "mFu",
+    joined: "n",
+    long: {
+        "--message": "message",
+        "--file": "file",
+        "--trailer": "trailer",
+        "--local-user": "value",
+        "--cleanup": "value",
+        "--sort": "value",
+        "--format": "value",
+        "--contains": "value",
+        "--no-contains": "value",
+        "--merged": "value",
+        "--no-merged": "value",
+        "--points-at": "value",
+    },
+};
+const GIT_VALUE_OPTIONS = new Set(["-c", "--git-dir", "--work-tree", "--namespace", "--config-env", "--super-prefix"]);
+// The messages git commit and git tag are given. A push is the pre-push hook's to check, since only git knows
+// what it sends.
+function gitPosts(args, stdin, cwd, written) {
+    let dir = cwd;
+    let i = 0;
+    for (; i < args.length; i++) {
+        const arg = args[i];
+        if (arg === "-C") {
+            const to = args[++i];
+            if (to !== undefined && !to.includes(UNKNOWN))
+                dir = resolve(dir, to);
+        }
+        else if (GIT_VALUE_OPTIONS.has(arg))
+            i++;
+        else if (!arg.startsWith("-"))
+            break;
+    }
+    const command = args[i];
+    const options = command === "commit" ? COMMIT : command === "tag" ? TAG : undefined;
+    if (options === undefined)
+        return [];
+    return messages(args.slice(i + 1), options, reader(stdin, dir, written)).map(([where, text]) => ({
+        where,
+        kind: "commit",
+        text,
+        cwd: dir,
+    }));
+}
+// Each -m is a paragraph of the one message.
+function messages(args, options, read) {
+    const paragraphs = [];
+    const texts = [];
+    const take = (kind, value) => {
+        if (kind === "message")
+            paragraphs.push(value);
+        else if (kind === "trailer")
+            texts.push([`a trailer of ${options.where}`, value]);
+        else if (kind === "file")
+            texts.push([value === "-" ? options.where : `${options.where}, from ${value}`, read(value)]);
+    };
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        if (arg === "--")
+            break;
+        if (arg.startsWith("--")) {
+            const eq = arg.indexOf("=");
+            const kind = options.long[eq < 0 ? arg : arg.slice(0, eq)];
+            if (kind === undefined)
+                continue;
+            const value = eq < 0 ? args[++i] : arg.slice(eq + 1);
+            if (value !== undefined)
+                take(kind, value);
+        }
+        else if (arg.startsWith("-")) {
+            // Short options cluster, as in -am "message".
+            for (let j = 1; j < arg.length; j++) {
+                const flag = arg[j];
+                if (options.joined.includes(flag))
+                    break;
+                if (!options.short.includes(flag))
+                    continue;
+                const value = j + 1 < arg.length ? arg.slice(j + 1) : args[++i];
+                if (value !== undefined)
+                    take(flag === "m" ? "message" : flag === "F" ? "file" : "value", value);
+                break;
+            }
+        }
+    }
+    if (paragraphs.length > 0)
+        texts.unshift([options.where, paragraphs.join("\n\n")]);
+    return texts;
+}
+// Keys that name where a post goes, such as the account a repository belongs to, not what it says.
+const DESTINATION_KEYS = new Set(["owner", "repo"]);
+// An MCP tool whose server or name says GitHub, in any case, including one a plugin bundles.
+export function isGithubTool(name) {
+    return name.startsWith("mcp__") && /github/i.test(name);
+}
+// Every string a GitHub tool is given, but for tools that only read. A file's contents are checked as the lines a
+// push would add to it.
+export function mcpPosts(toolName, input, cwd) {
+    const tool = toolName.slice(toolName.lastIndexOf("__") + 2);
+    if (/^(get|list|search|read)_|_read$/.test(tool))
+        return [];
+    const kind = toolKind(tool);
+    const posts = [];
+    const walk = (value, path) => {
+        if (typeof value === "string") {
+            posts.push({ where: `${path || "the input"} of ${tool}`, kind, text: value, cwd });
+        }
+        else if (Array.isArray(value)) {
+            value.forEach((v, i) => walk(v, `${path}[${i}]`));
+        }
+        else if (value !== null && typeof value === "object") {
+            const entries = Object.entries(value);
+            const record = value;
+            const isFile = typeof record.path === "string" && typeof record.content === "string";
+            if (isFile) {
+                const file = record.path;
+                posts.push({ where: `${file}, as ${tool} writes it`, kind: "commit", text: record.content, cwd, file });
+            }
+            for (const [key, v] of entries) {
+                if (DESTINATION_KEYS.has(key) || (isFile && key === "content"))
+                    continue;
+                walk(v, path ? `${path}.${key}` : key);
+            }
+        }
+    };
+    walk(input, "");
+    return posts;
+}
+function toolKind(tool) {
+    if (/comment/.test(tool))
+        return "comment";
+    if (/review/.test(tool))
+        return "review";
+    if (/pull/.test(tool))
+        return "pr";
+    if (/issue/.test(tool))
+        return "issue";
+    if (/commit|file|push|branch|tag/.test(tool))
+        return "commit";
+    return "comment";
+}
+// The JSON string values in a request body, each with its path.
+function leaves(value, path = "") {
+    if (typeof value === "string")
+        return [[path || "the text", value]];
+    if (Array.isArray(value))
+        return value.flatMap((v, i) => leaves(v, `${path}[${i}]`));
+    if (value === null || typeof value !== "object")
+        return [];
+    return Object.entries(value).flatMap(([key, v]) => DESTINATION_KEYS.has(key) ? [] : leaves(v, path ? `${path}.${key}` : key));
+}
+// The shell source of the first thing in a text that the shell fills in.
+export function firstUnknown(text) {
+    const start = text.indexOf(UNKNOWN);
+    const end = text.indexOf(UNKNOWN_END, start);
+    return text.slice(start + 1, end < 0 ? undefined : end);
+}

package/dist/cli.js

@@ -0,0 +1,51 @@
+#!/usr/bin/env node
+import { spawnSync } from "node:child_process";
+import { realpathSync } from "node:fs";
+import { homedir, hostname, tmpdir, userInfo } from "node:os";
+import { fileURLToPath } from "node:url";
+import { main } from "./main.js";
+function systemIdentity() {
+    let user;
+    try {
+        user = userInfo().username;
+    }
+    catch {
+        user = process.env.USER ?? process.env.USERNAME ?? "";
+    }
+    const tempDirs = [tmpdir()];
+    try {
+        tempDirs.push(realpathSync(tempDirs[0]));
+    }
+    catch { }
+    return { user, home: homedir(), host: hostname(), tempDirs, emails: gitEmails() };
+}
+// Every user.email git uses here, from each config file it reads: one set in a repository doesn't hide the global
+// one. An address an includeIf sets for another folder isn't read.
+// No git, or no address, means none to check.
+function gitEmails() {
+    const result = spawnSync("git", ["config", "--get-all", "user.email"], { encoding: "utf8" });
+    if (result.error?.code === "ENOENT" || result.status === 1)
+        return [];
+    if (result.error)
+        throw new Error(`can't run git: ${result.error.message}`);
+    if (result.status !== 0)
+        throw new Error(`git config failed: ${result.stderr.trim()}`);
+    return result.stdout.split("\n").filter((e) => e.trim() !== "");
+}
+async function readStdin() {
+    const chunks = [];
+    for await (const chunk of process.stdin)
+        chunks.push(chunk);
+    return Buffer.concat(chunks);
+}
+process.exitCode = await main({
+    argv: process.argv.slice(2),
+    env: process.env,
+    platform: process.platform,
+    cwd: process.cwd(),
+    identity: systemIdentity,
+    command: [process.execPath, fileURLToPath(import.meta.url)],
+    readStdin,
+    out: (text) => process.stdout.write(text),
+    err: (text) => process.stderr.write(text),
+});

package/dist/config.js

@@ -0,0 +1,193 @@
+import { existsSync, readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { isBlanketEmail, isBlanketPath } from "./checks.js";
+import { escapeRegExp, fold, termPattern } from "./normalize.js";
+import { parseToml } from "./toml.js";
+export const USER_FILE = "config.toml";
+export const REPO_FILE = ".second-read.toml";
+export class ConfigError extends Error {
+}
+const ALLOW_KEYS = { allowed_words: "allowedWords", allowed_emails: "allowedEmails", allowed_paths: "allowedPaths" };
+// The platform's config folder. SECOND_READ_CONFIG_DIR overrides it, which is how tests keep away from the real one.
+export function configDir(env, platform, home) {
+    if (env.SECOND_READ_CONFIG_DIR)
+        return env.SECOND_READ_CONFIG_DIR;
+    if (platform === "win32")
+        return join(env.APPDATA || join(home, "AppData", "Roaming"), "second-read");
+    return join(env.XDG_CONFIG_HOME || join(home, ".config"), "second-read");
+}
+// A missing user file means no private terms yet, not a failure: the other checks still run.
+export function loadUserConfig(path) {
+    if (!existsSync(path))
+        return { terms: [], allowedWords: [], allowedEmails: [], allowedPaths: [], allowedNames: [] };
+    const values = parseFile(path);
+    return {
+        terms: stringList(values, "terms", path),
+        ...allowLists(values, path, ["terms", "allowed_names"]),
+        allowedNames: stringList(values, "allowed_names", path),
+    };
+}
+// A repository's file holds only an allowlist. It's checked in, so a private term in it would be posted.
+export function loadRepoConfig(path, terms) {
+    const source = readText(path);
+    const values = parseText(source, path);
+    if (Object.hasOwn(values, "terms")) {
+        throw new ConfigError(`${path}: private terms belong in your own config file, never in a repository`);
+    }
+    if (Object.hasOwn(values, "allowed_names")) {
+        throw new ConfigError(`${path}: allowed_names belongs in your own config file, since naming your account or machine in a ` +
+            `repository posts it`);
+    }
+    const folded = fold(source).text;
+    for (const term of terms) {
+        const match = termPattern(term)?.exec(folded);
+        if (match) {
+            const line = folded.slice(0, match.index).split("\n").length;
+            throw new ConfigError(`${path}: line ${line} names one of your private terms; take it out of the repository`);
+        }
+    }
+    // Anyone who can change the repository can change this file, so it can't switch a whole check off.
+    // The user's own file can, since it never leaves the machine.
+    const lists = allowLists(values, path, ["exempt_files"]);
+    for (const entry of lists.allowedPaths) {
+        if (isBlanketPath(entry)) {
+            throw new ConfigError(`${path}: allowed_paths entry ${JSON.stringify(entry)} takes in the whole home folder or a temp folder; ` +
+                `a repository can allow only narrower paths`);
+        }
+    }
+    for (const entry of lists.allowedEmails) {
+        if (isBlanketEmail(entry)) {
+            throw new ConfigError(`${path}: allowed_emails entry ${JSON.stringify(entry)} has no fixed domain; ` +
+                `a repository has to name one, as in "*@example.com"`);
+        }
+    }
+    const exemptFiles = stringList(values, "exempt_files", path);
+    for (const entry of exemptFiles) {
+        if (isBlanketGlob(entry)) {
+            throw new ConfigError(`${path}: exempt_files entry ${JSON.stringify(entry)} is made only of wildcards, so it takes in nearly ` +
+                `every file; a repository can exempt only narrower globs, as in "src/**/*.test.ts"`);
+        }
+    }
+    return { ...lists, exemptFiles };
+}
+// A glob over paths from the top of the repository. "*" and "?" stay within one folder, "**" takes in any number of
+// folders, and a glob ending in "/" takes in everything under that folder. Case counts, as it does in git.
+export function exemptMatcher(globs) {
+    if (globs.length === 0)
+        return () => false;
+    const patterns = globs.map((glob) => {
+        const segments = globSegments(glob);
+        let source = "";
+        segments.forEach((segment, i) => {
+            const last = i === segments.length - 1;
+            if (segment === "**")
+                source += last ? ".*" : "(?:[^/]*/)*";
+            else {
+                source += segment.split("").map((c) => (c === "*" ? "[^/]*" : c === "?" ? "[^/]" : escapeRegExp(c))).join("");
+                if (!last)
+                    source += "/";
+            }
+        });
+        return new RegExp(`^${source}$`, "u");
+    });
+    return (file) => patterns.some((re) => re.test(file));
+}
+// A glob made only of wildcards and dots, such as "**", "**/?*" or "**/*.*", which leaves pre-push next to no added
+// lines to check. A folder of only "?" takes in names of that length, and one that starts with a dot only dotfiles,
+// so those are narrower.
+export function isBlanketGlob(glob) {
+    return globSegments(glob).every((segment) => /^[*?][*?.]*$/.test(segment) && segment.includes("*"));
+}
+function globSegments(glob) {
+    const trimmed = glob.replace(/^(?:\.?\/)+/, "");
+    return (trimmed === "" || trimmed.endsWith("/") ? trimmed + "**" : trimmed).split("/");
+}
+// The nearest .second-read.toml at or above `cwd`, up to the top of the git repository. Outside a repository
+// there is none, so a stray file in a parent folder is never picked up.
+export function findRepoConfig(cwd) {
+    const found = [];
+    let dir = cwd;
+    for (;;) {
+        const candidate = join(dir, REPO_FILE);
+        if (existsSync(candidate))
+            found.push(candidate);
+        if (existsSync(join(dir, ".git")))
+            return found[0];
+        const parent = dirname(dir);
+        if (parent === dir)
+            return undefined;
+        dir = parent;
+    }
+}
+export function mergeRules(user, repo) {
+    return {
+        terms: user.terms,
+        allowedWords: [...user.allowedWords, ...(repo?.allowedWords ?? [])],
+        allowedEmails: [...user.allowedEmails, ...(repo?.allowedEmails ?? [])],
+        allowedPaths: [...user.allowedPaths, ...(repo?.allowedPaths ?? [])],
+        allowedNames: user.allowedNames,
+        userAllowedEmails: user.allowedEmails,
+    };
+}
+export const USER_FILE_TEMPLATE = `# second-read: your private terms and allowlists.
+# This file stays on this machine. Never check it in, and never copy its terms into a repository.
+
+# Private terms: project, folder, character or client names that must never be posted.
+# Each is matched in any case, at word boundaries, with its words joined by spaces, hyphens or nothing:
+# "Example Project" also catches "example-project" and "ExampleProject".
+terms = [
+]
+
+# Money and account words that are fine to post everywhere, as a report names them (such as "billing").
+allowed_words = []
+
+# Your account or machine name, when it's an ordinary word that's fine to post, so it isn't flagged anywhere.
+# Common default machine names, such as "MacBook-Pro", are never flagged. Paths with your account name still are.
+allowed_names = []
+
+# Email addresses that are fine to post. "*" matches any run of characters, as in "*@example.com".
+# Your own address, git's user.email, is allowed only when it's written out here in full.
+allowed_emails = []
+
+# Paths that are fine to post, such as "~/.config/some-tool".
+allowed_paths = []
+`;
+function allowLists(values, path, extra) {
+    for (const key of Object.keys(values)) {
+        if (!Object.hasOwn(ALLOW_KEYS, key) && !extra.includes(key)) {
+            throw new ConfigError(`${path}: unknown key "${key}"`);
+        }
+    }
+    return {
+        allowedWords: stringList(values, "allowed_words", path),
+        allowedEmails: stringList(values, "allowed_emails", path),
+        allowedPaths: stringList(values, "allowed_paths", path),
+    };
+}
+function stringList(values, key, path) {
+    const value = values[key];
+    if (value === undefined)
+        return [];
+    if (!Array.isArray(value))
+        throw new ConfigError(`${path}: "${key}" must be an array of strings`);
+    return value;
+}
+function parseFile(path) {
+    return parseText(readText(path), path);
+}
+function parseText(source, path) {
+    try {
+        return parseToml(source);
+    }
+    catch (e) {
+        throw new ConfigError(`${path}: ${e.message}`);
+    }
+}
+function readText(path) {
+    try {
+        return readFileSync(path, "utf8");
+    }
+    catch (e) {
+        throw new ConfigError(`can't read ${path}: ${e.message}`);
+    }
+}