agent-sdd 1.0.3

package/dist/features/ready/application/RunReady.js

@@ -0,0 +1,572 @@
+import { CliFailure } from "../../../shared/domain/Errors.js";
+import { appendDiagnostic, emptyReport, } from "../../../shared/domain/LintReport.js";
+import { applicabilityRequiredRule, approvalRecordRules, assumptionDowngradeApprovalRule, baselineVersionRequiredRule, boundaryConcurrencyModelRule, boundaryPolicyRefRule, dataScopeRequiredRule, debtBudgetFormRule, deprecatedFieldsRequiredRule, fieldTypeRules, generatedArtifactSurfaceRefRule, lifecycleStatusRules, migrationCrossPartitionRule, migrationEnforcementStageRule, partitionDefaultPolicySetRule, REQUIRED_PARTITION_SECTIONS, sectionViolations, testObligationRules, weaselFindings, } from "../../../shared/domain/LintRules.js";
+import { reachableBoundaryIds } from "../../../shared/domain/BoundaryReachability.js";
+import { lintRecordsFromMarkdown, } from "../../../shared/domain/SpecRecord.js";
+import { actualBump, bumpAtLeast, classifyDiff, generatedArtifactStructuralDiffs, requiredSurfaceBumps, } from "../domain/SpecDiff.js";
+import { TOKEN_MECHANISM, token as computeToken, } from "../../../shared/domain/Token.js";
+import { aggregatedCheckViolations, aggregatedLintViolations, } from "../domain/AggregatedRules.js";
+import { parseMarkers, parseNearMisses, } from "../domain/MarkerParser.js";
+import { ruleOrphanCovers, ruleRemovedCompatActionMismatch, ruleRemovedNoCompatTest, ruleSurfaceUnapprovedRef, ruleUnapproved, ruleUncovered, ruleUnknownPartitionCovers, } from "../domain/Rules.js";
+import { envelopeFromError, } from "../domain/ReadyViolation.js";
+export async function runReady(cwd, input, ports) {
+    let config;
+    try {
+        config = await ports.config.config(cwd);
+    }
+    catch (error) {
+        return envelopeFromError(toReadyError(error, "config_invalid"));
+    }
+    const filterName = input.partitionFilter;
+    if (filterName !== undefined &&
+        !config.partitions.some((p) => p.name === filterName)) {
+        return envelopeFromError({
+            kind: "config_invalid",
+            message: `unknown partition: ${filterName} (configured: ${config.partitions.map((p) => p.name).join(", ") || "<none>"})`,
+        });
+    }
+    const partitions = config.partitions;
+    const evaluatedPartitions = filterName === undefined
+        ? partitions
+        : partitions.filter((p) => p.name === filterName);
+    /* 1. Parse spec files for every configured partition. */
+    const recordsResult = await parseAllPartitionRecords(cwd, partitions, ports);
+    if (recordsResult.kind === "error") {
+        return envelopeFromError(recordsResult.error);
+    }
+    const recordsByPartition = recordsResult.recordsByPartition;
+    /* 2. Scan test files for every configured partition. */
+    const markersResult = await scanAllPartitionMarkers(cwd, partitions, ports);
+    if (markersResult.kind === "error") {
+        return envelopeFromError(markersResult.error);
+    }
+    const { markersByPartition, advisories } = markersResult;
+    /* 3 + 4. Per-partition and marker-level rule evaluation. */
+    const violations = [
+        ...perPartitionViolations(evaluatedPartitions, recordsByPartition, markersByPartition),
+        ...markerLevelViolations(partitions, recordsByPartition, markersByPartition),
+    ];
+    /* 5. Aggregated lint over the union of evaluated partitions' spec files. */
+    const lintSpecPaths = uniqueSpecPaths(evaluatedPartitions, config);
+    const lintReport = await aggregatedLintReport(cwd, ports.files, lintSpecPaths, config.lint.approverBlocklist);
+    violations.push(...aggregatedLintViolations(lintReport.diagnostics));
+    /* 6. Aggregated check (skipped silently when not in a git repository). */
+    const checkOutcome = await aggregatedCheckOutcome(cwd, config, recordsByPartition, ports.git);
+    if (checkOutcome.kind === "error") {
+        return envelopeFromError(checkOutcome.error);
+    }
+    violations.push(...aggregatedCheckViolations(checkOutcome.outcome));
+    /* 7. Semver cascade + debt-budget monotonicity (only with --against). */
+    violations.push(...(await againstViolations(cwd, input, lintSpecPaths, ports)));
+    return { ok: violations.length === 0, error: null, violations, advisories };
+}
+/* ENF-004A / ENF-020 — semver cascade and debt-budget monotonicity run only
+ * with --against; without it, ready behaves exactly as in v0.3.x. */
+async function againstViolations(cwd, input, lintSpecPaths, ports) {
+    if (input.against === undefined || ports.git === undefined) {
+        return [];
+    }
+    return [
+        ...(await semverCascadeViolations(cwd, input.against, lintSpecPaths, ports.files, ports.git)),
+        ...(await debtBudgetMonotonicityViolations(cwd, input.against, lintSpecPaths, ports.files, ports.git)),
+    ];
+}
+/* Phase 1 parses spec files for every configured partition (orphan_covers needs
+ * global record knowledge even when --partition filters evaluation). */
+async function parseAllPartitionRecords(cwd, partitions, ports) {
+    const recordsByPartition = new Map();
+    for (const p of partitions) {
+        let entries;
+        try {
+            entries = await ports.files.resolveSpecFiles(cwd, p.specPaths);
+        }
+        catch (error) {
+            return { kind: "error", error: toReadyError(error, "config_invalid") };
+        }
+        const records = [];
+        for (const entry of entries) {
+            try {
+                records.push(...lintRecordsFromMarkdown(entry.path, entry.content));
+            }
+            catch (error) {
+                return {
+                    kind: "error",
+                    error: {
+                        kind: "spec_parse_failed",
+                        message: error instanceof Error ? error.message : String(error),
+                        file: entry.path,
+                    },
+                };
+            }
+        }
+        recordsByPartition.set(p.name, records);
+    }
+    return { kind: "ok", recordsByPartition };
+}
+/* Phase 2 scans test files per partition. A unique file is read once per
+ * partition that lists it; markers carry the file path. */
+async function scanAllPartitionMarkers(cwd, partitions, ports) {
+    const markersByPartition = new Map();
+    const nearMissByKey = new Map();
+    for (const p of partitions) {
+        if (p.testPaths.length === 0) {
+            markersByPartition.set(p.name, []);
+            continue;
+        }
+        let entries;
+        try {
+            entries = await ports.files.resolveTestFiles(cwd, p.testPaths);
+        }
+        catch (error) {
+            return {
+                kind: "error",
+                error: {
+                    kind: "unreadable_test_paths",
+                    message: error instanceof Error ? error.message : String(error),
+                },
+            };
+        }
+        const markers = [];
+        for (const entry of entries) {
+            markers.push(...parseMarkers(entry.content, entry.path));
+            for (const nm of parseNearMisses(entry.content, entry.path)) {
+                nearMissByKey.set(`${nm.file}:${nm.line}:${nm.text}`, {
+                    kind: "covers_near_miss",
+                    file: nm.file,
+                    line: nm.line,
+                    text: nm.text,
+                    remediation: `\`@covers ${nm.text}\` looks like a marker but fails the partition grammar (lowercase segments only); fix the prefix or remove the stray @covers text`,
+                });
+            }
+        }
+        markersByPartition.set(p.name, markers);
+    }
+    return {
+        kind: "ok",
+        markersByPartition,
+        advisories: [...nearMissByKey.values()],
+    };
+}
+function perPartitionViolations(evaluatedPartitions, recordsByPartition, markersByPartition) {
+    const violations = [];
+    for (const partition of evaluatedPartitions) {
+        const records = recordsByPartition.get(partition.name) ?? [];
+        const recordsById = new Map();
+        for (const r of records) {
+            recordsById.set(r.id, r);
+        }
+        const credited = new Map();
+        const ownMarkers = markersByPartition.get(partition.name) ?? [];
+        for (const m of ownMarkers) {
+            if (m.partition !== partition.name) {
+                continue;
+            }
+            const id = `${m.partition}:${m.id}`;
+            const list = credited.get(id) ?? [];
+            list.push(m);
+            credited.set(id, list);
+        }
+        const view = {
+            partition,
+            records,
+            recordsById,
+            creditedMarkersById: credited,
+        };
+        violations.push(...ruleUnapproved(view), ...ruleUncovered(view), ...ruleRemovedNoCompatTest(view), ...ruleRemovedCompatActionMismatch(view), ...ruleSurfaceUnapprovedRef(view));
+    }
+    return violations;
+}
+/* Phase 4 dedups markers by (file, line, partition, id) — a file listed in
+ * multiple partitions' test_paths must not be double-counted — then surfaces
+ * unknown_partition_covers and orphan_covers globally regardless of --partition. */
+function markerLevelViolations(partitions, recordsByPartition, markersByPartition) {
+    const partitionsByName = new Map(partitions.map((p) => [p.name, p]));
+    const seen = new Set();
+    const allMarkers = [];
+    for (const ms of markersByPartition.values()) {
+        for (const m of ms) {
+            const key = `${m.file}:${m.line}:${m.partition}:${m.id}`;
+            if (seen.has(key)) {
+                continue;
+            }
+            seen.add(key);
+            allMarkers.push(m);
+        }
+    }
+    const scanned = [];
+    for (const m of allMarkers) {
+        const fullId = `${m.partition}:${m.id}`;
+        const partition = partitionsByName.get(m.partition);
+        const isPartitionConfigured = partition !== undefined;
+        const records = isPartitionConfigured
+            ? (recordsByPartition.get(m.partition) ?? [])
+            : [];
+        const hasMatchingRecord = records.some((r) => r.id === fullId);
+        scanned.push({ marker: m, isPartitionConfigured, hasMatchingRecord });
+    }
+    return [...ruleUnknownPartitionCovers(scanned), ...ruleOrphanCovers(scanned)];
+}
+async function debtBudgetMonotonicityViolations(cwd, ref, specPaths, files, git) {
+    if (!(await git.isGitRepo(cwd))) {
+        return [];
+    }
+    const repoRoot = await git.repoRoot(cwd);
+    let curr;
+    try {
+        curr = await files.resolveSpecFiles(cwd, specPaths);
+    }
+    catch {
+        return [];
+    }
+    const currRecords = [];
+    for (const e of curr) {
+        currRecords.push(...lintRecordsFromMarkdown(e.path, e.content));
+    }
+    const prevRecordsByFile = new Map();
+    for (const e of curr) {
+        const prevContent = await git.readAtRef(repoRoot, ref, e.path);
+        if (prevContent === null) {
+            continue;
+        }
+        prevRecordsByFile.set(e.path, lintRecordsFromMarkdown(e.path, prevContent));
+    }
+    const prevRecords = [];
+    for (const arr of prevRecordsByFile.values()) {
+        prevRecords.push(...arr);
+    }
+    const out = [];
+    for (const part of currRecords.filter((r) => r.template === "Partition")) {
+        const currBudget = readDebtBudget(part);
+        if (currBudget === null) {
+            continue;
+        }
+        const prevPart = prevRecords.find((r) => r.id === part.id);
+        if (prevPart === undefined) {
+            continue;
+        }
+        const prevBudget = readDebtBudget(prevPart);
+        if (prevBudget === null) {
+            continue;
+        }
+        const violationKind = compareBudgets(currBudget, prevBudget);
+        if (violationKind === null) {
+            continue;
+        }
+        out.push({
+            kind: "debt_budget_increased",
+            id: part.id,
+            file: part.file,
+            line: part.line,
+            expected: violationKind.expected,
+            actual: violationKind.actual,
+            remediation: `Partition ${part.id} unmodeled_budget.current=${currBudget.current} (was ${prevBudget.current} at ${ref}, trend=${currBudget.trend}); ${violationKind.remediation}`,
+        });
+    }
+    return out;
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function readDebtBudget(rec) {
+    const b = rec.parsed.unmodeled_budget;
+    if (!isRecord(b)) {
+        return null;
+    }
+    const current = b.current;
+    const trend = b.trend;
+    if (typeof current !== "number") {
+        return null;
+    }
+    if (trend !== "monotonic_non_increasing" &&
+        trend !== "monotonic_decreasing") {
+        return null;
+    }
+    return { current, trend };
+}
+function compareBudgets(curr, prev) {
+    if (curr.trend === "monotonic_non_increasing") {
+        if (curr.current > prev.current) {
+            return {
+                expected: `<= ${prev.current}`,
+                actual: String(curr.current),
+                remediation: "trend=monotonic_non_increasing requires current <= previous current; reduce debt or weaken the trend",
+            };
+        }
+        return null;
+    }
+    /* monotonic_decreasing */
+    if (curr.current >= prev.current) {
+        return {
+            expected: `< ${prev.current}`,
+            actual: String(curr.current),
+            remediation: "trend=monotonic_decreasing requires current < previous current; reduce debt this PR",
+        };
+    }
+    return null;
+}
+async function semverCascadeViolations(cwd, ref, specPaths, files, git) {
+    if (!(await git.isGitRepo(cwd))) {
+        return [];
+    }
+    const repoRoot = await git.repoRoot(cwd);
+    let curr;
+    try {
+        curr = await files.resolveSpecFiles(cwd, specPaths);
+    }
+    catch {
+        return [];
+    }
+    const currRecords = [];
+    for (const e of curr) {
+        currRecords.push(...lintRecordsFromMarkdown(e.path, e.content));
+    }
+    const prevRecords = [];
+    for (const e of curr) {
+        const prevContent = await git.readAtRef(repoRoot, ref, e.path);
+        if (prevContent === null) {
+            continue;
+        } /* file new at HEAD — every record reads as additive content_change */
+        prevRecords.push(...lintRecordsFromMarkdown(e.path, prevContent));
+    }
+    const diffs = classifyDiff(prevRecords, currRecords);
+    const bumps = requiredSurfaceBumps(prevRecords, currRecords, diffs);
+    return [
+        ...surfaceCascadeViolations(bumps, currRecords),
+        ...gaStructuralViolations(prevRecords, currRecords, diffs, bumps),
+    ];
+}
+function surfaceCascadeViolations(bumps, currRecords) {
+    const out = [];
+    for (const b of bumps) {
+        const actual = actualBump(b.prevDeclaredVersion, b.declaredVersion);
+        if (b.required === "patch") {
+            continue;
+        }
+        if (bumpAtLeast(actual, b.required)) {
+            continue;
+        }
+        const surfaceRec = currRecords.find((r) => r.id === b.surfaceId);
+        out.push({
+            kind: "surface_semver_cascade",
+            id: b.surfaceId,
+            file: surfaceRec?.file,
+            line: surfaceRec?.line,
+            expected: b.required,
+            actual: actual ?? "patch",
+            remediation: `Surface ${b.surfaceId} reachable change requires a ${b.required} bump (declared ${b.prevDeclaredVersion ?? "?"} → ${b.declaredVersion ?? "?"}). Driven by: ${b.drivenBy
+                .map((d) => `${d.id} (${d.classification})`)
+                .slice(0, 4)
+                .join(", ")}${b.drivenBy.length > 4 ? "..." : ""}`,
+        });
+    }
+    return out;
+}
+/*
+ * ENF-019 — emit a dedicated GA-naming violation (always, for traceability)
+ * when a published GA structural diff lacks a major Surface bump.
+ */
+function gaStructuralViolations(prevRecords, currRecords, diffs, bumps) {
+    const out = [];
+    const gaDiffs = generatedArtifactStructuralDiffs(prevRecords, currRecords, diffs);
+    for (const ga of gaDiffs) {
+        const surfaceRec = currRecords.find((r) => r.id === ga.surfaceId);
+        const bump = bumps.find((b) => b.surfaceId === ga.surfaceId);
+        const actual = bump !== undefined
+            ? actualBump(bump.prevDeclaredVersion, bump.declaredVersion)
+            : null;
+        if (bumpAtLeast(actual, "major")) {
+            continue;
+        }
+        out.push({
+            kind: "generated_artifact_structural_diff_unbumped",
+            id: ga.surfaceId,
+            file: surfaceRec?.file,
+            line: surfaceRec?.line,
+            expected: "major",
+            actual: actual ?? "patch",
+            remediation: `Surface ${ga.surfaceId} reaches GeneratedArtifact ${ga.generatedArtifactId} (published_surface=yes) with ${ga.classification}; structural diff in a published GA requires a major bump on the parent Surface (ENF-019).`,
+        });
+    }
+    return out;
+}
+function uniqueSpecPaths(evaluated, config) {
+    const all = evaluated.length > 0
+        ? evaluated.flatMap((p) => p.specPaths)
+        : config.lint.specFiles;
+    return [...new Set(all)];
+}
+async function aggregatedLintReport(cwd, files, specPaths, approverBlocklist) {
+    let report = emptyReport();
+    if (specPaths.length === 0) {
+        return report;
+    }
+    let entries;
+    try {
+        entries = await files.resolveSpecFiles(cwd, specPaths);
+    }
+    catch {
+        return report;
+    }
+    for (const entry of entries) {
+        report = lintFileInto(report, entry, approverBlocklist);
+    }
+    return report;
+}
+function lintFileInto(report, entry, approverBlocklist) {
+    let next = report;
+    if (looksLikePartitionFile(entry.content)) {
+        for (const v of sectionViolations(entry.content)) {
+            next = appendDiagnostic(next, {
+                severity: "error",
+                rule: v.rule,
+                file: entry.path,
+                message: v.message,
+            });
+        }
+    }
+    const records = lintRecordsFromMarkdown(entry.path, entry.content);
+    const boundaryIds = reachableBoundaryIds(records);
+    for (const w of weaselFindings(entry.content, records)) {
+        const where = w.field !== undefined
+            ? `normative field ${w.field}`
+            : `normative section "${w.section}"`;
+        next = appendDiagnostic(next, {
+            severity: "error",
+            rule: "sdd:weasel-word",
+            file: entry.path,
+            line: w.line,
+            message: `Banned phrase "${w.word}" in ${where} (SDD §5.1).`,
+        });
+    }
+    for (const rec of records) {
+        for (const d of [
+            ...lifecycleStatusRules(rec),
+            ...approvalRecordRules(rec),
+            ...testObligationRules(rec),
+            ...fieldTypeRules(rec),
+            ...baselineVersionRequiredRule(rec),
+            ...deprecatedFieldsRequiredRule(rec),
+            ...assumptionDowngradeApprovalRule(rec, approverBlocklist),
+            ...partitionDefaultPolicySetRule(rec),
+            ...generatedArtifactSurfaceRefRule(rec),
+            ...boundaryPolicyRefRule(rec, boundaryIds),
+            ...boundaryConcurrencyModelRule(rec, boundaryIds),
+            ...applicabilityRequiredRule(rec, boundaryIds),
+            ...dataScopeRequiredRule(rec, boundaryIds),
+            ...migrationEnforcementStageRule(rec, records),
+            ...migrationCrossPartitionRule(rec),
+            ...debtBudgetFormRule(rec),
+        ]) {
+            next = appendDiagnostic(next, d);
+        }
+    }
+    return next;
+}
+function looksLikePartitionFile(markdown) {
+    const firstNumberedHeading = REQUIRED_PARTITION_SECTIONS[0];
+    const re = new RegExp(`^##\\s+${firstNumberedHeading.replace(/\./g, "\\.").replace(/ /g, "\\s+")}`, "m");
+    return re.test(markdown);
+}
+async function aggregatedCheckOutcome(cwd, config, recordsByPartition, git) {
+    const inRepo = await git.isGitRepo(cwd).catch(() => false);
+    if (!inRepo) {
+        return { kind: "outcome", outcome: { kind: "skipped" } };
+    }
+    const baseline = findBaseline(config.baselineId, recordsByPartition);
+    if (baseline === null) {
+        /*
+         * Baseline-id pattern is enforced by config; absence of the block in spec
+         * is itself a baseline-stale-equivalent. We surface it via aggregated
+         * check rather than treating it as evaluate-failure, to match `sdd lint`'s
+         * tolerance of unparseable BL blocks (it just doesn't lint them).
+         */
+        return { kind: "outcome", outcome: { kind: "skipped" } };
+    }
+    if (baseline.freshnessToken === "TODO" ||
+        baseline.freshnessToken.length === 0) {
+        return { kind: "outcome", outcome: { kind: "skipped" } };
+    }
+    let repoRoot;
+    try {
+        repoRoot = await git.repoRoot(cwd);
+    }
+    catch {
+        return { kind: "outcome", outcome: { kind: "skipped" } };
+    }
+    let dirty;
+    try {
+        dirty = await git.dirtyPaths(repoRoot, config.discoveryScope);
+    }
+    catch (error) {
+        return {
+            kind: "error",
+            error: {
+                kind: "internal",
+                message: error instanceof Error ? error.message : String(error),
+            },
+        };
+    }
+    if (dirty.length > 0) {
+        return { kind: "outcome", outcome: { kind: "dirty", dirtyPaths: dirty } };
+    }
+    let bytes;
+    try {
+        bytes = await git.treeBytes(repoRoot, config.discoveryScope);
+    }
+    catch (error) {
+        return {
+            kind: "error",
+            error: {
+                kind: "internal",
+                message: error instanceof Error ? error.message : String(error),
+            },
+        };
+    }
+    const recomputed = computeToken(bytes);
+    if (recomputed === baseline.freshnessToken) {
+        return { kind: "outcome", outcome: { kind: "match" } };
+    }
+    return {
+        kind: "outcome",
+        outcome: {
+            kind: "stale",
+            recordedToken: baseline.freshnessToken,
+            recomputedToken: recomputed,
+        },
+    };
+}
+function findBaseline(baselineId, recordsByPartition) {
+    for (const records of recordsByPartition.values()) {
+        for (const rec of records) {
+            if (rec.id !== baselineId) {
+                continue;
+            }
+            const ft = rec.parsed.freshness_token;
+            if (typeof ft === "string") {
+                return { freshnessToken: ft };
+            }
+        }
+    }
+    return null;
+}
+function toReadyError(error, fallback) {
+    if (error instanceof CliFailure) {
+        if (error.reason === "config-missing" ||
+            error.reason === "config-invalid") {
+            return {
+                kind: "config_invalid",
+                message: error.message,
+                file: error.path,
+            };
+        }
+    }
+    return {
+        kind: fallback,
+        message: error instanceof Error ? error.message : String(error),
+    };
+}
+/* Side-effect-free public helper for tests/unit symmetry. */
+export function appendLintDiagnostic(report, d) {
+    return appendDiagnostic(report, d);
+}
+export { TOKEN_MECHANISM };

package/dist/features/ready/domain/AggregatedRules.d.ts

@@ -0,0 +1,16 @@
+import type { Diagnostic } from "../../../shared/domain/LintReport.js";
+import type { ReadyViolation } from "./ReadyViolation.js";
+export declare function aggregatedLintViolations(diagnostics: readonly Diagnostic[]): ReadyViolation[];
+export type AggregatedCheckOutcome = {
+    kind: "match";
+} | {
+    kind: "dirty";
+    dirtyPaths: readonly string[];
+} | {
+    kind: "stale";
+    recordedToken: string;
+    recomputedToken: string;
+} | {
+    kind: "skipped";
+};
+export declare function aggregatedCheckViolations(outcome: AggregatedCheckOutcome): ReadyViolation[];

package/dist/features/ready/domain/AggregatedRules.js

@@ -0,0 +1,42 @@
+/*
+ * Adapt a LintReport's error-severity diagnostics into ReadyViolations of kind
+ * `aggregated_lint`. Per OQ-015 (default a), warn-severity diagnostics are
+ * dropped; only errors block the merge gate.
+ */
+export function aggregatedLintViolations(diagnostics) {
+    const out = [];
+    for (const d of diagnostics) {
+        if (d.severity !== "error") {
+            continue;
+        }
+        out.push({
+            kind: "aggregated_lint",
+            file: d.file,
+            line: d.line,
+            remediation: d.message,
+            source: d.rule,
+        });
+    }
+    return out;
+}
+export function aggregatedCheckViolations(outcome) {
+    if (outcome.kind === "match" || outcome.kind === "skipped") {
+        return [];
+    }
+    if (outcome.kind === "dirty") {
+        const head = outcome.dirtyPaths[0];
+        return [
+            {
+                kind: "aggregated_check",
+                remediation: `baseline-dirty: ${outcome.dirtyPaths.length} uncommitted path(s) inside discovery_scope`,
+                file: head,
+            },
+        ];
+    }
+    return [
+        {
+            kind: "aggregated_check",
+            remediation: `baseline-stale: recorded freshness_token does not match recomputed (recorded=${outcome.recordedToken.slice(0, 12)}…, recomputed=${outcome.recomputedToken.slice(0, 12)}…)`,
+        },
+    ];
+}

package/dist/features/ready/domain/MarkerParser.d.ts

@@ -0,0 +1,17 @@
+export interface Marker {
+    partition: string;
+    id: string;
+    tail: Record<string, string>;
+    file: string;
+    line: number;
+}
+export declare const ALLOWED_MARKER_KEYS: ReadonlySet<string>;
+export interface NearMissMarker {
+    text: string;
+    file: string;
+    line: number;
+}
+/** `@covers`-shaped tokens that look like a marker attempt (valid id tail) but
+ *  fail the strict partition grammar. Strictly-valid markers are excluded. */
+export declare function parseNearMisses(text: string, file: string): NearMissMarker[];
+export declare function parseMarkers(text: string, file: string): Marker[];