@peterxiaoyang/superspec 0.1.0

package/dist/src/invariants.js

@@ -0,0 +1,363 @@
+import { existsSync, readFileSync, statSync } from "node:fs";
+import { reason, renderList, safe_within } from "./util.js";
+import { sidecar_business_invariants_path, sidecar_test_contract_path } from "./paths.js";
+import { live_pass } from "./evidence.js";
+import { parse_test_contract_records, splitList } from "./tasks.js";
+const INV_ID_RE = /\bINV-[A-Za-z0-9_-]+\b/g;
+const REQUIRED_INVARIANT_FIELDS = [
+    "statement",
+    "scope",
+    "source_anchors",
+    "acceptance_refs",
+    "risk_refs",
+    "confidence",
+    "enforcement_level",
+    "test_refs_or_review_only_reason",
+    "verification",
+];
+const CONFIDENCE_VALUES = new Set(["confirmed", "source-backed", "inferred", "uncertain"]);
+const ENFORCEMENT_VALUES = new Set(["automated-test", "review-checklist", "human-confirmation", "advisory"]);
+function readTextIfFile(filePath) {
+    if (!existsSync(filePath) || !statSync(filePath).isFile())
+        return "";
+    return readFileSync(filePath, "utf8");
+}
+function parseMarkdownRow(line) {
+    return line.trim().replace(/^\|/, "").replace(/\|$/, "").split("|").map((cell) => cell.trim());
+}
+function isSeparatorRow(cells) {
+    return cells.length > 0 && cells.every((cell) => /^:?-{3,}:?$/.test(cell));
+}
+function normalizeHeader(header) {
+    return header.trim().toLowerCase().replace(/\s+/g, "_");
+}
+function tableLinesAfterHeading(text, heading) {
+    const lines = text.split(/\r?\n/);
+    const headingRe = new RegExp(`^##\\s+${heading}\\s*$`, "i");
+    const start = lines.findIndex((line) => headingRe.test(line.trim()));
+    if (start < 0)
+        return [];
+    const table = [];
+    let started = false;
+    for (const line of lines.slice(start + 1)) {
+        const trimmed = line.trim();
+        if (!trimmed && !started)
+            continue;
+        if (!trimmed.startsWith("|")) {
+            if (started)
+                break;
+            continue;
+        }
+        started = true;
+        table.push(line);
+    }
+    return table;
+}
+export function business_invariants_text(changeRoot) {
+    return readTextIfFile(sidecar_business_invariants_path(changeRoot));
+}
+export function parse_business_invariant_records(changeRoot) {
+    const text = business_invariants_text(changeRoot);
+    const table = tableLinesAfterHeading(text, "Invariants");
+    if (table.length < 3)
+        return [];
+    const headers = parseMarkdownRow(table[0]).map(normalizeHeader);
+    const records = [];
+    for (const line of table.slice(1)) {
+        const cells = parseMarkdownRow(line);
+        if (isSeparatorRow(cells))
+            continue;
+        const record = {};
+        headers.forEach((header, idx) => {
+            record[header] = cells[idx] ?? "";
+        });
+        records.push(record);
+    }
+    return records;
+}
+function invariantId(record) {
+    return String(record["inv-id"] ?? record.inv_id ?? record.id ?? "").trim();
+}
+function isCreatedAfterImplementation(record) {
+    return ["true", "yes", "1"].includes(String(record.created_after_implementation ?? "").trim().toLowerCase());
+}
+function isHardInvariant(record) {
+    const confidence = String(record.confidence ?? "").trim();
+    const enforcement = String(record.enforcement_level ?? "").trim();
+    return (confidence === "confirmed" || confidence === "source-backed") && enforcement !== "advisory";
+}
+function enforcementLevel(record) {
+    return String(record.enforcement_level ?? "").trim();
+}
+export function business_invariant_ids(changeRoot) {
+    const records = parse_business_invariant_records(changeRoot);
+    if (records.length > 0)
+        return new Set(records.map(invariantId).filter(Boolean));
+    return new Set([...business_invariants_text(changeRoot).matchAll(INV_ID_RE)].map((match) => match[0]));
+}
+export function hard_business_invariant_ids(changeRoot) {
+    const hard = new Set();
+    for (const record of parse_business_invariant_records(changeRoot)) {
+        const id = invariantId(record);
+        if (!id)
+            continue;
+        if (isHardInvariant(record) && !isCreatedAfterImplementation(record))
+            hard.add(id);
+    }
+    return hard;
+}
+export function automated_hard_business_invariant_ids(changeRoot) {
+    const hard = new Set();
+    for (const record of parse_business_invariant_records(changeRoot)) {
+        const id = invariantId(record);
+        if (!id)
+            continue;
+        if (isHardInvariant(record) && !isCreatedAfterImplementation(record) && enforcementLevel(record) === "automated-test")
+            hard.add(id);
+    }
+    return hard;
+}
+export function post_implementation_business_invariant_ids(changeRoot) {
+    const ids = new Set();
+    for (const record of parse_business_invariant_records(changeRoot)) {
+        const id = invariantId(record);
+        if (id && isCreatedAfterImplementation(record))
+            ids.add(id);
+    }
+    return ids;
+}
+export function human_confirmation_business_invariant_ids(changeRoot) {
+    const ids = new Set();
+    for (const record of parse_business_invariant_records(changeRoot)) {
+        const id = invariantId(record);
+        if (!id)
+            continue;
+        const enforcement = String(record.enforcement_level ?? "").trim();
+        if (enforcement === "human-confirmation")
+            ids.add(id);
+    }
+    return ids;
+}
+export function business_invariant_validation_reasons(changeRoot) {
+    const filePath = sidecar_business_invariants_path(changeRoot);
+    if (!existsSync(filePath) || !statSync(filePath).isFile()) {
+        return [reason("missing_business_invariants", "sidecar .superspec/artifacts/business-invariants.md missing")];
+    }
+    const text = business_invariants_text(changeRoot);
+    if (!text.trim())
+        return [reason("missing_business_invariants", "sidecar .superspec/artifacts/business-invariants.md empty")];
+    const records = parse_business_invariant_records(changeRoot);
+    const problems = [];
+    if (records.length === 0) {
+        problems.push(reason("invalid_business_invariants", "business-invariants.md has no parseable Invariants table"));
+        return problems;
+    }
+    const seen = new Set();
+    records.forEach((record, idx) => {
+        const row = idx + 1;
+        const id = invariantId(record);
+        if (!/^INV-[A-Za-z0-9_-]+$/.test(id)) {
+            problems.push(reason("invalid_invariant_ref", `business-invariants row ${row} has invalid INV-ID ${id || "<empty>"}`));
+        }
+        else if (seen.has(id)) {
+            problems.push(reason("invalid_invariant_ref", `duplicate business invariant id ${id}`));
+        }
+        else {
+            seen.add(id);
+        }
+        for (const field of REQUIRED_INVARIANT_FIELDS) {
+            if (!String(record[field] ?? "").trim()) {
+                problems.push(reason("invalid_business_invariants", `${id || `row ${row}`}: missing ${field}`));
+            }
+        }
+        const confidence = String(record.confidence ?? "").trim();
+        if (confidence && !CONFIDENCE_VALUES.has(confidence)) {
+            problems.push(reason("invalid_business_invariants", `${id || `row ${row}`}: unsupported confidence ${confidence}`));
+        }
+        const enforcement = String(record.enforcement_level ?? "").trim();
+        if (enforcement && !ENFORCEMENT_VALUES.has(enforcement)) {
+            problems.push(reason("invalid_business_invariants", `${id || `row ${row}`}: unsupported enforcement_level ${enforcement}`));
+        }
+        if (isCreatedAfterImplementation(record) && isHardInvariant(record)) {
+            problems.push(reason("post_implementation_invariant_backfill", `${id || `row ${row}`}: created_after_implementation hard invariant cannot satisfy current RED/GREEN contract`));
+        }
+    });
+    return problems;
+}
+export function test_contract_invariant_ids(changeRoot) {
+    const refs = new Set();
+    for (const record of parse_test_contract_records(changeRoot)) {
+        for (const ref of record.invariant_refs)
+            refs.add(ref);
+    }
+    return refs;
+}
+export function task_invariant_refs(tasks) {
+    const refs = new Set();
+    for (const task of Object.values(tasks)) {
+        for (const ref of splitList(task.attrs.invariant_refs ?? ""))
+            refs.add(ref);
+    }
+    return refs;
+}
+export function evidence_invariant_refs(ev) {
+    const value = ev.invariant_refs;
+    if (Array.isArray(value))
+        return new Set(value.map((item) => String(item)).filter(Boolean));
+    if (typeof value === "string")
+        return new Set(splitList(value));
+    return new Set();
+}
+export function red_green_invariant_ids(evidences) {
+    const ids = new Set();
+    for (const ev of live_pass(evidences, { kind: "test_run" })) {
+        for (const id of evidence_invariant_refs(ev))
+            ids.add(id);
+    }
+    return ids;
+}
+export function evidence_invariant_ref_reasons(evidences, taskId, declared, validIds, semanticStatus) {
+    const problems = [];
+    for (const ev of evidences) {
+        const refs = evidence_invariant_refs(ev);
+        if (declared.size > 0 && refs.size === 0) {
+            problems.push(reason("missing_invariant_ref", `task ${taskId} ${semanticStatus} evidence requires invariant_refs`));
+            continue;
+        }
+        for (const inv of refs) {
+            if (declared.size > 0 && !declared.has(inv)) {
+                problems.push(reason("invariant_not_honored", `task ${taskId} ${semanticStatus} invariant_ref ${inv} not in declared invariant_refs ${renderList([...declared].sort())}`));
+            }
+            if (validIds.size > 0 && !validIds.has(inv)) {
+                problems.push(reason("invalid_invariant_ref", `task ${taskId} ${semanticStatus} references unknown invariant ${inv}`));
+            }
+        }
+    }
+    return problems;
+}
+export function evidence_test_contract_invariant_reasons(evidences, taskId, byTest, semanticStatus) {
+    const problems = [];
+    for (const ev of evidences) {
+        const testId = typeof ev.test_id === "string" ? ev.test_id : "";
+        const expected = byTest.get(testId) ?? new Set();
+        if (expected.size === 0)
+            continue;
+        const actual = evidence_invariant_refs(ev);
+        if (actual.size === 0) {
+            problems.push(reason("missing_invariant_ref", `task ${taskId} ${semanticStatus} evidence for ${testId} requires invariant_refs ${renderList([...expected].sort())}`));
+            continue;
+        }
+        const missing = [...expected].filter((inv) => !actual.has(inv)).sort();
+        if (missing.length > 0) {
+            problems.push(reason("invariant_not_honored", `task ${taskId} ${semanticStatus} evidence for ${testId} missing invariant_refs ${renderList(missing)}`));
+        }
+    }
+    return problems;
+}
+function firstMarkdownTableLines(text) {
+    const lines = text.split(/\r?\n/);
+    const table = [];
+    let started = false;
+    for (const line of lines) {
+        const trimmed = line.trim();
+        if (!trimmed.startsWith("|")) {
+            if (started)
+                break;
+            continue;
+        }
+        started = true;
+        table.push(line);
+    }
+    return table;
+}
+function parse_invariant_matrix_records(text) {
+    const table = firstMarkdownTableLines(text);
+    if (table.length < 3)
+        return { records: [], missing_columns: ["table"] };
+    const headers = parseMarkdownRow(table[0]).map(normalizeHeader);
+    const invIdx = headers.findIndex((header) => header === "inv-id" || header === "inv_id" || header.includes("invariant") || header.includes("inv"));
+    const statusIdx = headers.findIndex((header) => header === "status" || header.includes("状态"));
+    const evidenceIdx = headers.findIndex((header) => header.includes("evidence") || header.includes("proof") || header.includes("证据"));
+    const missingColumns = [];
+    if (invIdx < 0)
+        missingColumns.push("INV-ID");
+    if (statusIdx < 0)
+        missingColumns.push("status");
+    if (evidenceIdx < 0)
+        missingColumns.push("evidence");
+    if (missingColumns.length > 0)
+        return { records: [], missing_columns: missingColumns };
+    const records = [];
+    for (const line of table.slice(1)) {
+        const cells = parseMarkdownRow(line);
+        if (isSeparatorRow(cells))
+            continue;
+        const invId = (cells[invIdx] ?? "").match(INV_ID_RE)?.[0] ?? "";
+        if (!invId)
+            continue;
+        records.push({
+            inv_id: invId,
+            status: cells[statusIdx] ?? "",
+            evidence: cells[evidenceIdx] ?? "",
+        });
+    }
+    return { records, missing_columns: [] };
+}
+function escapeRegExp(text) {
+    return text.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function cellReferencesEvidenceId(cell, evidenceId) {
+    if (!evidenceId)
+        return false;
+    const tokenCandidates = cell
+        .split(/[\s,;|()[\]{}<>`'"]+/)
+        .map((item) => item.trim().replace(/^[.:]+|[.:]+$/g, ""))
+        .filter(Boolean);
+    if (tokenCandidates.includes(evidenceId))
+        return true;
+    const pattern = new RegExp(`(^|[^A-Za-z0-9_-])${escapeRegExp(evidenceId)}([^A-Za-z0-9_-]|$)`);
+    return pattern.test(cell);
+}
+function referencedLiveEvidenceIds(cell, liveEvidenceIds) {
+    return [...liveEvidenceIds].filter((evidenceId) => cellReferencesEvidenceId(cell, evidenceId)).sort();
+}
+export function invariant_matrix_coverage_reasons(changeRoot, ev, evidences) {
+    const matrixRef = ev.invariant_matrix_ref;
+    if (typeof matrixRef !== "string" || !matrixRef)
+        return [];
+    const filePath = safe_within(changeRoot, matrixRef);
+    if (filePath === null || !existsSync(filePath) || !statSync(filePath).isFile())
+        return [];
+    const required = hard_business_invariant_ids(changeRoot);
+    if (required.size === 0)
+        return [];
+    const { records, missing_columns: missingColumns } = parse_invariant_matrix_records(readFileSync(filePath, "utf8"));
+    const label = String(ev._path ?? ev.evidence_id ?? "verification_review");
+    const reasons = [];
+    if (missingColumns.length > 0) {
+        reasons.push(reason("invariant_matrix_incomplete", `${label}: invariant_matrix_ref ${matrixRef} missing parseable columns/table: ${renderList(missingColumns)}`, missingColumns));
+        return reasons;
+    }
+    const byId = new Map(records.map((record) => [record.inv_id, record]));
+    const missing = [...required].filter((id) => !byId.has(id)).sort();
+    if (missing.length > 0) {
+        reasons.push(reason("invariant_matrix_incomplete", `${label}: invariant matrix missing hard business invariants: ${renderList(missing)}`, missing));
+    }
+    const liveEvidenceIds = new Set(live_pass(evidences)
+        .map((item) => String(item.evidence_id ?? ""))
+        .filter(Boolean));
+    for (const id of [...required].sort()) {
+        const record = byId.get(id);
+        if (!record)
+            continue;
+        const status = record.status.trim().toLowerCase();
+        if (status !== "pass" && status !== "accepted") {
+            reasons.push(reason("invariant_matrix_incomplete", `${label}: invariant ${id} matrix status must be pass or accepted, got ${record.status || "<empty>"}`, [id]));
+        }
+        const evidenceIds = referencedLiveEvidenceIds(record.evidence, liveEvidenceIds);
+        if (evidenceIds.length === 0) {
+            reasons.push(reason("invariant_matrix_incomplete", `${label}: invariant ${id} matrix evidence must reference at least one live/pass evidence_id`, [id]));
+        }
+    }
+    return reasons;
+}

package/dist/src/openspec.d.ts

@@ -0,0 +1,18 @@
+import type { JsonMap, Reason } from "./util.ts";
+export declare function openspec_status(change: string): JsonMap;
+export declare function openspec_validate(change: string): [boolean, string];
+export declare function openspec_version(): string;
+export declare function openspec_status_shape_reasons(status: JsonMap): Reason[];
+export declare function artifact_status_map(status: JsonMap): Record<string, string>;
+export declare function is_ready_or_done(status: JsonMap, artifact: string): boolean;
+export declare function is_done(status: JsonMap, artifact: string): boolean;
+export declare function all_done(status: JsonMap): boolean;
+export declare function openspec_floor_route(status: JsonMap): string;
+export declare function normalize_route_phase(route: string): string;
+export declare function normalize_gate(gate: string): string;
+export declare function gate_route_phase(gate: string): string;
+export declare function effective_route_phase(status: JsonMap, requestedRoute: string, decision: JsonMap): string;
+export declare function status_fingerprint(status: JsonMap): string;
+export declare function get_change_root(status: JsonMap): string;
+export declare function get_repo_root(status: JsonMap): string;
+export declare function repo_root_from_cwd(start?: string): string;

package/dist/src/openspec.js

@@ -0,0 +1,157 @@
+import { dirname, join, resolve, sep } from "node:path";
+import { existsSync } from "node:fs";
+import { GATE_ALIASES, GATE_ROUTE, GuardError, ROUTE_ALIASES, ROUTE_ORDER, fingerprint_obj, isObject, reason, repr, runCommand, } from "./util.js";
+export function openspec_status(change) {
+    const proc = runCommand("openspec", ["status", "--change", change, "--json"], { timeout: 30_000 });
+    if (proc.error) {
+        throw new GuardError(`openspec_unavailable: status failed: ${proc.error.message}`);
+    }
+    if (proc.status !== 0) {
+        throw new GuardError(`openspec_unavailable: status exit ${proc.status}: ${proc.stderr.trim()}`);
+    }
+    try {
+        return JSON.parse(proc.stdout);
+    }
+    catch (err) {
+        throw new GuardError(`openspec_unavailable: status json parse failed`);
+    }
+}
+export function openspec_validate(change) {
+    const proc = runCommand("openspec", ["validate", change], { timeout: 60_000 });
+    if (proc.error) {
+        throw new GuardError(`openspec_unavailable: validate failed: ${proc.error.message}`);
+    }
+    return [proc.status === 0, `${proc.stdout}${proc.stderr}`.trim()];
+}
+export function openspec_version() {
+    const proc = runCommand("openspec", ["--version"], { timeout: 15_000 });
+    if (proc.error || proc.status !== 0)
+        return "unknown";
+    const raw = (proc.stdout || proc.stderr).trim();
+    const match = raw.match(/\d+\.\d+\.\d+/);
+    return match ? match[0] : raw || "unknown";
+}
+export function openspec_status_shape_reasons(status) {
+    const problems = [];
+    if (typeof status.changeRoot !== "string" || !status.changeRoot) {
+        problems.push(reason("openspec_status_incompatible", "status.changeRoot missing or not a string"));
+    }
+    const planningHome = status.planningHome;
+    if (!isObject(planningHome) || typeof planningHome.root !== "string") {
+        problems.push(reason("openspec_status_incompatible", "status.planningHome.root missing or not a string"));
+    }
+    const artifacts = status.artifacts;
+    if (!Array.isArray(artifacts)) {
+        problems.push(reason("openspec_status_incompatible", "status.artifacts missing or not a list"));
+    }
+    else {
+        artifacts.forEach((artifact, idx) => {
+            if (!isObject(artifact)) {
+                problems.push(reason("openspec_status_incompatible", `status.artifacts[${idx}] is not an object`));
+                return;
+            }
+            if (typeof artifact.id !== "string") {
+                problems.push(reason("openspec_status_incompatible", `status.artifacts[${idx}].id missing`));
+            }
+            if (!["done", "ready", "blocked"].includes(String(artifact.status))) {
+                problems.push(reason("openspec_status_incompatible", `status.artifacts[${idx}].status unsupported: ${repr(artifact.status)}`));
+            }
+            if ("missingDeps" in artifact && !Array.isArray(artifact.missingDeps)) {
+                problems.push(reason("openspec_status_incompatible", `status.artifacts[${idx}].missingDeps must be a list`));
+            }
+        });
+    }
+    if (!Array.isArray(status.applyRequires)) {
+        problems.push(reason("openspec_status_incompatible", "status.applyRequires missing or not a list"));
+    }
+    return problems;
+}
+export function artifact_status_map(status) {
+    const out = {};
+    for (const artifact of Array.isArray(status.artifacts) ? status.artifacts : []) {
+        if (isObject(artifact) && typeof artifact.id === "string") {
+            out[artifact.id] = String(artifact.status ?? "unknown");
+        }
+    }
+    return out;
+}
+export function is_ready_or_done(status, artifact) {
+    return ["ready", "done"].includes(artifact_status_map(status)[artifact]);
+}
+export function is_done(status, artifact) {
+    return artifact_status_map(status)[artifact] === "done";
+}
+export function all_done(status) {
+    const values = Object.values(artifact_status_map(status));
+    return values.length > 0 && values.every((item) => item === "done");
+}
+export function openspec_floor_route(status) {
+    if (is_done(status, "tasks"))
+        return "apply";
+    if (is_done(status, "design"))
+        return "propose";
+    if (is_done(status, "proposal") && is_done(status, "specs"))
+        return "propose";
+    if (is_ready_or_done(status, "proposal") && is_ready_or_done(status, "specs"))
+        return "propose";
+    return "init";
+}
+export function normalize_route_phase(route) {
+    return ROUTE_ALIASES[route] ?? route;
+}
+export function normalize_gate(gate) {
+    return GATE_ALIASES[gate] ?? gate;
+}
+export function gate_route_phase(gate) {
+    return GATE_ROUTE[normalize_gate(gate)] ?? "propose";
+}
+export function effective_route_phase(status, requestedRoute, decision) {
+    const requested = normalize_route_phase(requestedRoute);
+    if (decision.allowed)
+        return requested;
+    const floor = openspec_floor_route(status);
+    const requestedOrder = ROUTE_ORDER[requested];
+    if (requestedOrder === undefined)
+        return floor;
+    return requestedOrder <= ROUTE_ORDER[floor] ? requested : floor;
+}
+export function status_fingerprint(status) {
+    const artifacts = (Array.isArray(status.artifacts) ? status.artifacts : [])
+        .map((artifact) => ({
+        id: artifact.id,
+        status: artifact.status,
+        missingDeps: [...(Array.isArray(artifact.missingDeps) ? artifact.missingDeps : [])].sort(),
+    }))
+        .sort((a, b) => String(a.id).localeCompare(String(b.id)));
+    const core = {
+        artifacts,
+        applyRequires: [...(Array.isArray(status.applyRequires) ? status.applyRequires : [])].sort(),
+    };
+    return fingerprint_obj(core);
+}
+export function get_change_root(status) {
+    if (!status.changeRoot)
+        throw new GuardError("openspec_unavailable: status missing changeRoot");
+    return resolve(String(status.changeRoot));
+}
+export function get_repo_root(status) {
+    const root = isObject(status.planningHome) ? status.planningHome.root : undefined;
+    if (root)
+        return resolve(String(root));
+    const changeRoot = get_change_root(status);
+    const parts = changeRoot.split(sep);
+    if (parts.length < 3)
+        throw new GuardError("openspec_unavailable: cannot derive repo root");
+    return resolve(changeRoot, "..", "..", "..");
+}
+export function repo_root_from_cwd(start = process.cwd()) {
+    let dir = resolve(start);
+    while (true) {
+        if (existsSync(join(dir, "openspec", "changes")))
+            return dir;
+        const parent = dirname(dir);
+        if (parent === dir)
+            return resolve(start);
+        dir = parent;
+    }
+}

package/dist/src/paths.d.ts

@@ -0,0 +1,22 @@
+import type { JsonMap, Reason } from "./util.ts";
+export declare function superspec_dir(changeRoot: string): string;
+export declare function project_superspec_dir(repoRoot: string): string;
+export declare function sidecar_artifacts_dir(changeRoot: string): string;
+export declare function sidecar_test_contract_path(changeRoot: string): string;
+export declare function sidecar_business_invariants_path(changeRoot: string): string;
+export declare function sidecar_discovery_path(changeRoot: string): string;
+export declare function sidecar_output_path(changeRoot: string, relPath: string): string;
+export declare function write_sidecar_text(changeRoot: string, relPath: string, text: string): string;
+export declare function write_sidecar_json(changeRoot: string, relPath: string, data: JsonMap): string;
+export declare function config_file(changeRoot: string): string;
+export declare function project_config_file(repoRoot: string): string;
+export declare function required_sidecar_paths(changeRoot: string): string[];
+export declare function ensure_sidecar_layout(changeRoot: string): void;
+export declare function ensure_state_layout(changeRoot: string): void;
+export declare function find_forbidden_aliases(repoRoot: string, changeRoot: string): string[];
+export declare function read_skill_frontmatter_name(skillPath: string): string | null;
+export declare function read_agent_toml_name(agentPath: string): string | null;
+export declare function parse_simple_yaml(filePath: string): JsonMap;
+export declare function merge_config(base: JsonMap, override: JsonMap): JsonMap;
+export declare function validate_config_keys(config: JsonMap, source: string): Reason[];
+export declare function load_config(repoRoot: string, changeRoot: string): [JsonMap, Reason[]];