codictator 0.0.0 → 0.1.2

package/dist/features/packs/manifest.js

@@ -0,0 +1,180 @@
+// SPEC §4.4.3 steps 2–4: manifest checks with the codes §8 owns. Reads the
+// fields the checks need; the kernel schema check owns the full format.
+import { err, makeError, ok } from "../../kernel/index.js";
+// SPEC §4.4.2: built-in pack ids; a custom pack must not equal one (§4.4.3).
+const BUILTIN_IDS = [
+    "core",
+    "typescript",
+    "dotnet",
+    "python",
+];
+export function isBuiltinPackId(id) {
+    return BUILTIN_IDS.includes(id);
+}
+// SPEC §4.4.6 plus code: every kind accepted in an enforcer declaration.
+// Parametric kinds resolve deferred until step 5.4 wires them.
+const KNOWN_ENFORCER_KINDS = [
+    "code",
+    "pattern-forbid",
+    "pattern-require",
+    "path-placement",
+    "file-size",
+    "file-required",
+    "import-forbid",
+    "command-forbid",
+    "json-key",
+    "external",
+];
+// SPEC §4.4.6: the budget a declaration carries when it names none. The
+// self-test runs every fixture inside twice this budget (CDX-E215).
+const DEFAULT_BUDGET_MS = 1000;
+export function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+// Bracket access through a variable keeps noPropertyAccessFromIndexSignature
+// satisfied without tripping useLiteralKeys (kernel narrows the same way).
+export function field(record, name) {
+    return record[name];
+}
+function declError(id, detail, fix) {
+    return err(makeError("CDX-E205", `pack enforcer "${id}" ${detail}`, `${fix}`));
+}
+// SPEC §4.4.3 step 4: the declaration must name a known kind and carry a
+// usable id; anything else is unresolvable (CDX-E205). External bindings
+// are shape-checked here, fully interpreted by step 5.5.
+export function narrowEnforcerDecl(entry) {
+    if (!isRecord(entry)) {
+        return declError("unknown", "must be a JSON object", "Give the enforcer an id and a §4.4.6 kind, then reload the pack.");
+    }
+    const id = field(entry, "id");
+    const kind = field(entry, "kind");
+    if (typeof id !== "string" || id.length === 0) {
+        return declError("unknown", "needs a non-empty string id", "Give the enforcer an id matching the rule that names it, then reload.");
+    }
+    if (typeof kind !== "string" || !KNOWN_ENFORCER_KINDS.includes(kind)) {
+        return declError(id, "names an unknown kind", "Use a §4.4.6 kind or code, then reload the pack.");
+    }
+    const moduleValue = field(entry, "module");
+    if (moduleValue !== undefined && typeof moduleValue !== "string") {
+        return declError(id, "carries a non-string module", "Name the owning module as a string, then reload the pack.");
+    }
+    const budgetValue = field(entry, "budgetMs");
+    if (budgetValue !== undefined &&
+        (typeof budgetValue !== "number" ||
+            !Number.isInteger(budgetValue) ||
+            budgetValue <= 0)) {
+        return declError(id, "carries a budgetMs that is not a positive integer", "Give the enforcer a positive integer budgetMs, then reload the pack.");
+    }
+    const moduleDecl = typeof moduleValue === "string" ? { module: moduleValue } : {};
+    // SPEC §7.3: args ride along opaquely; the owning enforcer module
+    // narrows them (parametric kinds in step 5.4, external in step 5.5).
+    const argsDecl = "args" in entry ? { args: field(entry, "args") } : {};
+    if (kind !== "external") {
+        return ok({
+            id,
+            kind,
+            ...moduleDecl,
+            ...argsDecl,
+            budgetMs: typeof budgetValue === "number" ? budgetValue : DEFAULT_BUDGET_MS,
+        });
+    }
+    const tool = field(entry, "tool");
+    const ruleMap = field(entry, "ruleMap");
+    if (typeof tool !== "string" || tool.length === 0 || !isRecord(ruleMap)) {
+        return declError(id, "needs a tool id and a ruleMap object", "Bind the enforcer to a config.tools id with a ruleMap, then reload.");
+    }
+    const mapped = {};
+    for (const key of Object.keys(ruleMap)) {
+        const target = ruleMap[key];
+        if (typeof target !== "string" || target.length === 0) {
+            return declError(id, "carries a ruleMap value that is not a rule id", "Map every tool rule id to a rule id of the same pack, then reload.");
+        }
+        mapped[key] = target;
+    }
+    return ok({
+        id,
+        kind,
+        ...moduleDecl,
+        ...argsDecl,
+        budgetMs: typeof budgetValue === "number" ? budgetValue : DEFAULT_BUDGET_MS,
+        tool,
+        ruleMap: mapped,
+    });
+}
+function manifestError(detail) {
+    return err(makeError("CDX-E203", `pack manifest is invalid: ${detail}`, "Fix the pack.json so it matches schema/pack.schema.json, then reload the pack."));
+}
+// The kernel schema check owns the format; this narrows unknown to the
+// manifest shape the checks below read (config narrows the same way).
+export function narrowManifest(value) {
+    if (!isRecord(value)) {
+        return manifestError("the manifest must be a JSON object");
+    }
+    const id = field(value, "id");
+    if (typeof id !== "string" || id.length === 0) {
+        return manifestError('the manifest needs a non-empty string "id"');
+    }
+    const rules = field(value, "rules");
+    if (!Array.isArray(rules)) {
+        return manifestError('the manifest needs a "rules" array');
+    }
+    for (const rule of rules) {
+        if (!isRecord(rule)) {
+            return manifestError("every rule must be a JSON object");
+        }
+        if (typeof field(rule, "id") !== "string" ||
+            typeof field(rule, "enforcer") !== "string") {
+            return manifestError('every rule needs string "id" and "enforcer"');
+        }
+    }
+    const enforcers = field(value, "enforcers");
+    if (!Array.isArray(enforcers)) {
+        return manifestError('the manifest needs an "enforcers" array');
+    }
+    // Every field above is verified, and the kernel schema check verified
+    // the rest, so the unknown-to-manifest narrowing is exact.
+    return ok(value);
+}
+// SPEC §4.4.3 steps 2–4 plus the §4.4.5 ruleMap boundary (CDX-E210).
+export function checkPack(manifest, builtin) {
+    const seen = new Set();
+    for (const rule of manifest.rules) {
+        if (seen.has(rule.id)) {
+            return err(makeError("CDX-E202", `duplicate rule id "${rule.id}" in pack "${manifest.id}"`, "Give every rule a globally unique id, then reload the pack."));
+        }
+        seen.add(rule.id);
+    }
+    if (!builtin) {
+        if (BUILTIN_IDS.includes(manifest.id)) {
+            return err(makeError("CDX-E204", `custom pack id "${manifest.id}" collides with a built-in pack id`, "Rename the pack id so it is not core, typescript, dotnet or python, then reload."));
+        }
+        for (const rule of manifest.rules) {
+            if (!rule.id.startsWith(`${manifest.id}/`)) {
+                return err(makeError("CDX-E204", `custom pack "${manifest.id}" rule id "${rule.id}" must start with "${manifest.id}/"`, "Rename the rule id under the pack namespace, then reload."));
+            }
+        }
+    }
+    const declared = new Map();
+    for (const entry of manifest.enforcers) {
+        const narrowed = narrowEnforcerDecl(entry);
+        if (!narrowed.ok) {
+            return err(narrowed.error);
+        }
+        declared.set(narrowed.value.id, narrowed.value);
+    }
+    for (const rule of manifest.rules) {
+        if (!declared.has(rule.enforcer)) {
+            return err(makeError("CDX-E205", `rule "${rule.id}" names unknown enforcer "${rule.enforcer}"`, "Declare the enforcer in the pack or use a built-in parametric enforcer (§4.4.6), then reload."));
+        }
+    }
+    for (const decl of declared.values()) {
+        if (decl.kind === "external" && decl.ruleMap !== undefined) {
+            for (const target of Object.values(decl.ruleMap)) {
+                if (!seen.has(target)) {
+                    return err(makeError("CDX-E210", `external enforcer "${decl.id}" maps to "${target}" outside pack "${manifest.id}"`, "Map the tool rule to a rule id of the same pack, then reload."));
+                }
+            }
+        }
+    }
+    return ok(undefined);
+}

package/dist/features/packs/params.d.ts

@@ -0,0 +1,2 @@
+import { type Result } from "../../kernel/index.ts";
+export declare function checkParam(ruleId: string, name: string, value: unknown): Result<void>;

package/dist/features/packs/params.js

@@ -0,0 +1,90 @@
+// SPEC §4.4.4: tunable params carry default within bound along a stricter
+// direction. The loader stores params opaquely, so malformed entries fail
+// here (CDX-E216), not at load.
+import { err, makeError, ok } from "../../kernel/index.js";
+import { field, isRecord } from "./manifest.js";
+function paramError(ruleId, name, detail) {
+    return err(makeError("CDX-E216", `rule "${ruleId}" param "${name}" ${detail}`, "Keep every tunable default within its bound along the stricter direction, then re-run the self-test."));
+}
+function isFiniteNumber(value) {
+    return typeof value === "number" && Number.isFinite(value);
+}
+function checkNumeric(ruleId, name, integer, def, bound, stricter, rest) {
+    const defOk = integer ? Number.isInteger(def) : isFiniteNumber(def);
+    const boundOk = integer ? Number.isInteger(bound) : isFiniteNumber(bound);
+    if (!defOk || !boundOk) {
+        return paramError(ruleId, name, `needs numeric default and bound, got ${typeof def} and ${typeof bound}`);
+    }
+    const defValue = def;
+    const boundValue = bound;
+    for (const edge of ["min", "max"]) {
+        const limit = field(rest, edge);
+        const limitOk = limit === undefined ||
+            (integer ? Number.isInteger(limit) : isFiniteNumber(limit));
+        if (!limitOk) {
+            return paramError(ruleId, name, `carries a non-numeric ${edge}`);
+        }
+    }
+    const min = field(rest, "min");
+    const max = field(rest, "max");
+    if (typeof min === "number" && defValue < min) {
+        return paramError(ruleId, name, "sets a default below min");
+    }
+    if (typeof max === "number" && defValue > max) {
+        return paramError(ruleId, name, "sets a default above max");
+    }
+    if (stricter === "lower" && defValue > boundValue) {
+        return paramError(ruleId, name, "sets a default looser than bound");
+    }
+    if (stricter === "higher" && defValue < boundValue) {
+        return paramError(ruleId, name, "sets a default looser than bound");
+    }
+    return ok(undefined);
+}
+function checkStringList(ruleId, name, def, bound, stricter) {
+    if (!Array.isArray(def) || !def.every((entry) => typeof entry === "string")) {
+        return paramError(ruleId, name, "needs a string[] default");
+    }
+    if (!Array.isArray(bound) ||
+        !bound.every((entry) => typeof entry === "string")) {
+        return paramError(ruleId, name, "needs a string[] bound");
+    }
+    if (stricter === "subset") {
+        for (const entry of def) {
+            if (!bound.includes(entry)) {
+                return paramError(ruleId, name, `sets a default ${entry} outside bound`);
+            }
+        }
+    }
+    if (stricter === "superset") {
+        for (const entry of bound) {
+            if (!def.includes(entry)) {
+                return paramError(ruleId, name, `sets a bound ${entry} outside default`);
+            }
+        }
+    }
+    return ok(undefined);
+}
+// SPEC §4.4.4: every tunable param has default within bound and a stricter
+// direction.
+export function checkParam(ruleId, name, value) {
+    if (!isRecord(value)) {
+        return paramError(ruleId, name, "must be a param object");
+    }
+    const type = field(value, "type");
+    if (type !== "integer" && type !== "number" && type !== "string[]") {
+        return paramError(ruleId, name, "needs a type of integer, number or string[]");
+    }
+    const stricter = field(value, "stricter");
+    if (stricter !== "lower" &&
+        stricter !== "higher" &&
+        stricter !== "subset" &&
+        stricter !== "superset" &&
+        stricter !== "policy") {
+        return paramError(ruleId, name, "needs a stricter direction");
+    }
+    if (type === "string[]") {
+        return checkStringList(ruleId, name, field(value, "default"), field(value, "bound"), stricter);
+    }
+    return checkNumeric(ruleId, name, type === "integer", field(value, "default"), field(value, "bound"), stricter, value);
+}

package/dist/features/packs/registry.d.ts

@@ -0,0 +1,11 @@
+import type { Ports, Result } from "../../kernel/index.ts";
+import type { Enforcer } from "../engine/index.ts";
+import type { ExternalOptions, ToolDecl } from "./enforcers/external.ts";
+import type { PackManifest } from "./index.ts";
+import { type EnforcerDecl } from "./manifest.ts";
+export interface RegistryOptions {
+    readonly onToolEvent?: ExternalOptions["onToolEvent"];
+}
+export declare function livePorts(root: string): Promise<Result<Ports>>;
+export declare function resolvePackEnforcers(manifest: PackManifest, decls: ReadonlyArray<EnforcerDecl>, ports: Ports, tools: ReadonlyArray<ToolDecl>, options?: RegistryOptions): Result<Array<Enforcer>>;
+export declare function resolveManifestEnforcers(manifest: PackManifest, ports: Ports): Result<Array<Enforcer>>;

package/dist/features/packs/registry.js

@@ -0,0 +1,136 @@
+import { err, makeError, NodeEnv, NodeFs, NodeGit, NodeNet, NodeProc, ok, SystemClock, } from "../../kernel/index.js";
+import { resolveCodeEnforcer } from "./enforcers/code.js";
+import { resolveExternal } from "./enforcers/external-check.js";
+import { isParametricKind, resolveParametric } from "./enforcers/parametric.js";
+import { narrowEnforcerDecl } from "./manifest.js";
+// SPEC §4.4.3 step 4: a deferred stub throws CDX-E901 when run — violating
+// fixtures cannot pass on it, and the engine turns the throw into a block
+// (§4.3.8). Kinds owned by later modules, orphan decls no rule references,
+// unbound parametric decls and external bindings with no config.tools row
+// all defer here.
+function deferredEnforcer(decl, note) {
+    const owner = decl.kind === "code"
+        ? `module ${decl.module ?? "unassigned"}`
+        : `kind ${decl.kind}`;
+    const until = note ?? "until its owning module lands";
+    return {
+        id: decl.id,
+        kinds: [],
+        budgetMs: decl.budgetMs,
+        check: () => {
+            throw makeError("CDX-E901", `enforcer "${decl.id}" (${owner}) is deferred ${until}`, "Implement the enforcer in its owning module, then re-run the pack self-test.");
+        },
+    };
+}
+function wiredKind(kind) {
+    return kind === "external" || isParametricKind(kind);
+}
+function missingToolEnforcer(decl) {
+    return {
+        id: decl.id,
+        kinds: [],
+        budgetMs: decl.budgetMs,
+        check: () => {
+            throw makeError("CDX-E901", `enforcer "${decl.id}" needs config.tools id "${decl.tool ?? "unknown"}" bound before it resolves`, "Declare the tool in config.tools, then reload the pack.");
+        },
+    };
+}
+// SPEC §4.4.5: production callers inject repo-rooted ports; without them the
+// registry falls back to a drive-rooted live bundle mirroring the loader's
+// own read path, so builtin self-checks behave like the loader's reads.
+export async function livePorts(root) {
+    const made = await NodeFs.create({ root });
+    if (!made.ok) {
+        return err(made.error);
+    }
+    const proc = new NodeProc();
+    return ok({
+        fs: made.value,
+        proc,
+        net: new NodeNet(),
+        clock: new SystemClock(),
+        git: new NodeGit(proc, "."),
+        env: new NodeEnv(),
+    });
+}
+export function resolvePackEnforcers(manifest, decls, ports, tools, options = {}) {
+    const byDecl = new Map();
+    for (const rule of manifest.rules) {
+        const bound = byDecl.get(rule.enforcer);
+        if (bound === undefined) {
+            byDecl.set(rule.enforcer, [rule]);
+        }
+        else {
+            bound.push(rule);
+        }
+    }
+    const resolved = [];
+    for (const decl of decls) {
+        const rules = (byDecl.get(decl.id) ?? []).sort((a, b) => a.id < b.id ? -1 : a.id > b.id ? 1 : 0);
+        if (rules.length === 0 || (!wiredKind(decl.kind) && decl.kind !== "code")) {
+            resolved.push(deferredEnforcer(decl));
+            continue;
+        }
+        if (decl.kind === "code") {
+            for (const rule of rules) {
+                const made = resolveCodeEnforcer(decl, rule, ports);
+                if (!made.ok) {
+                    return err(made.error);
+                }
+                if (made.value === undefined) {
+                    resolved.push(deferredEnforcer(decl, "until its owning module lands"));
+                    continue;
+                }
+                resolved.push(made.value);
+            }
+            continue;
+        }
+        for (const rule of rules) {
+            if (isParametricKind(decl.kind)) {
+                const made = resolveParametric(decl, rule, ports);
+                if (!made.ok) {
+                    return err(made.error);
+                }
+                if (made.value === undefined) {
+                    resolved.push(deferredEnforcer(decl, "until its §4.4.6 args bind it"));
+                    continue;
+                }
+                resolved.push(made.value);
+            }
+            else {
+                const tool = tools.find((entry) => entry.id === decl.tool);
+                if (tool === undefined) {
+                    resolved.push(missingToolEnforcer(decl));
+                    continue;
+                }
+                const externalOptions = options.onToolEvent === undefined
+                    ? {}
+                    : { onToolEvent: options.onToolEvent };
+                const made = resolveExternal(decl, rule, ports, tool, externalOptions);
+                if (!made.ok) {
+                    return err(made.error);
+                }
+                resolved.push(made.value);
+            }
+        }
+    }
+    resolved.sort((a, b) => (a.id < b.id ? -1 : a.id > b.id ? 1 : 0));
+    return ok(resolved);
+}
+// SPEC §4.19.2 + §4.3.3: repo-rooted enforcers for command evaluation. The
+// loader resolves enforcers against its own read ports; a command evaluating
+// a repo must narrow the manifest decls itself and resolve them against the
+// root-confined ports, so scope files read repo-relatively (§4.1.1).
+// External tools stay unbound here (their config.tools wiring lands with
+// the custom-pack flow); unbound externals resolve inert, never failing.
+export function resolveManifestEnforcers(manifest, ports) {
+    const decls = [];
+    for (const entry of manifest.enforcers) {
+        const narrowed = narrowEnforcerDecl(entry);
+        if (!narrowed.ok) {
+            return err(narrowed.error);
+        }
+        decls.push(narrowed.value);
+    }
+    return resolvePackEnforcers(manifest, decls, ports, []);
+}

package/dist/features/packs/selftest.d.ts

@@ -0,0 +1,3 @@
+import type { Result } from "../../kernel/index.ts";
+import type { Pack } from "./index.ts";
+export declare function selfTest(pack: Pack): Promise<Result<void>>;

package/dist/features/packs/selftest.js

@@ -0,0 +1,127 @@
+import { err, makeError, ok } from "../../kernel/index.js";
+import { TRIGGERS, } from "../engine/index.js";
+import { checkParam } from "./params.js";
+const SELF_TEST_CONFIG_HASH = "self-test";
+// No clock port reaches the self-test signature, so the context carries a
+// synthetic instant. Enforcers under test decide on fixture content, never
+// on wall time; real fixture runs take a real clock in a later phase.
+const SELF_TEST_NOW = "self-test";
+const TIMED_OUT = { timedOut: true };
+function toTrigger(value) {
+    if (typeof value === "string") {
+        for (const trigger of TRIGGERS) {
+            if (trigger === value) {
+                return trigger;
+            }
+        }
+    }
+    return "startup";
+}
+function testContext(rule) {
+    return {
+        trigger: toTrigger(rule.triggers[0]),
+        scope: { files: [] },
+        now: SELF_TEST_NOW,
+        configHash: SELF_TEST_CONFIG_HASH,
+    };
+}
+function thrownError(ruleId, enforcerId) {
+    return err(makeError("CDX-E901", `enforcer "${enforcerId}" threw during self-test of rule "${ruleId}"; the pack is inert`, "Fix the guard so it runs clean on every fixture, then re-run the pack self-test."));
+}
+// SPEC §4.4.4: every fixture run finishes inside twice the budget. The
+// timeout race detects exactly that without a clock port.
+function withBudget(pending, budgetMs) {
+    let timer;
+    const timeout = new Promise((_resolve, reject) => {
+        timer = setTimeout(() => {
+            reject(TIMED_OUT);
+        }, budgetMs * 2);
+    });
+    return Promise.race([pending, timeout]).finally(() => {
+        if (timer !== undefined) {
+            clearTimeout(timer);
+        }
+    });
+}
+async function runCase(enforcer, rule, name) {
+    let pending;
+    try {
+        pending = enforcer.check(testContext(rule), {});
+    }
+    catch {
+        return thrownError(rule.id, enforcer.id);
+    }
+    try {
+        return ok(await withBudget(pending, enforcer.budgetMs));
+    }
+    catch (error) {
+        if (error === TIMED_OUT) {
+            return err(makeError("CDX-E215", `rule "${rule.id}" fixture "${name}" exceeded twice its ${enforcer.budgetMs} ms budget`, "Give the enforcer a larger budgetMs in the pack manifest, then re-run the self-test."));
+        }
+        return thrownError(rule.id, enforcer.id);
+    }
+}
+// SPEC §4.4.4: the enforcer for a self-test is found by the name the rule
+// declares, falling back to the rule id so hand-built packs keep working.
+function resolveEnforcer(pack, rule) {
+    for (const enforcer of pack.enforcers) {
+        if (enforcer.id === rule.enforcer) {
+            return enforcer;
+        }
+    }
+    for (const enforcer of pack.enforcers) {
+        if (enforcer.id === rule.id) {
+            return enforcer;
+        }
+    }
+    return undefined;
+}
+async function selfTestRule(pack, rule) {
+    if (rule.fixtures.violating.length === 0) {
+        return err(makeError("CDX-E211", `rule "${rule.id}" has no violating fixture`, "Add a violating fixture under fixtures/<rule-slug>/violating/, then re-run the self-test."));
+    }
+    if (rule.remediation.length === 0 || rule.remediation === rule.reason) {
+        return err(makeError("CDX-E214", `rule "${rule.id}" remediation is empty or repeats its reason`, "Write remediation as Do-instead text distinct from Why, then re-run the self-test."));
+    }
+    for (const name of Object.keys(rule.params)) {
+        const checked = checkParam(rule.id, name, rule.params[name]);
+        if (!checked.ok) {
+            return err(checked.error);
+        }
+    }
+    const enforcer = resolveEnforcer(pack, rule);
+    if (enforcer === undefined) {
+        return err(makeError("CDX-E205", `rule "${rule.id}" names unknown enforcer "${rule.enforcer}"`, "Declare the enforcer in the pack or use a built-in parametric enforcer (§4.4.6), then re-run the self-test."));
+    }
+    for (const name of rule.fixtures.violating) {
+        const ran = await runCase(enforcer, rule, name);
+        if (!ran.ok) {
+            return err(ran.error);
+        }
+        if (!ran.value.some((finding) => finding.ruleId === rule.id)) {
+            return err(makeError("CDX-E212", `rule "${rule.id}" violating fixture "${name}" yielded no finding with this rule id`, "Strengthen the enforcer so the violating case blocks, then re-run the self-test."));
+        }
+    }
+    for (const name of rule.fixtures.passing) {
+        const ran = await runCase(enforcer, rule, name);
+        if (!ran.ok) {
+            return err(ran.error);
+        }
+        if (ran.value.some((finding) => finding.ruleId === rule.id)) {
+            return err(makeError("CDX-E213", `rule "${rule.id}" passing fixture "${name}" yielded a finding with this rule id`, "Narrow the enforcer so the passing case stays clean, then re-run the self-test."));
+        }
+    }
+    return ok(undefined);
+}
+// SPEC §4.4.4: self-test every rule against its fixtures before use. Rules
+// run in id order so the first failure is deterministic.
+export async function selfTest(pack) {
+    const rules = [...pack.manifest.rules].sort((a, b) => a.id < b.id ? -1 : a.id > b.id ? 1 : 0);
+    for (const rule of rules) {
+        const tested = await selfTestRule(pack, rule);
+        if (!tested.ok) {
+            return err(tested.error);
+        }
+    }
+    return ok(undefined);
+}

package/dist/features/records/bug-grammar.d.ts

@@ -0,0 +1,17 @@
+export type BugStatus = "open" | "fixed" | "wontfix";
+export interface BugRow {
+    readonly id: string;
+    readonly status: BugStatus;
+    readonly title: string;
+    readonly found: string;
+    readonly fix: string;
+    readonly regressionTest: string;
+}
+export interface BugFile {
+    readonly year: string;
+    readonly rows: ReadonlyArray<BugRow>;
+}
+export declare function parseBugFile(text: string): {
+    readonly file: BugFile | undefined;
+    readonly errors: ReadonlyArray<string>;
+};