@stsepelin/checktrail 0.1.0-alpha.1

package/dist/src/golangci-evidence.js

@@ -0,0 +1,92 @@
+import path from "node:path";
+import { z } from "zod";
+import { goScopeComplete } from "./go-scope.js";
+const schema = z.object({
+    Issues: z.array(z.object({
+        FromLinter: z.string().min(1),
+        Text: z.string().min(1),
+        Pos: z.object({
+            Filename: z.string(),
+            Line: z.number().int().positive(),
+            Column: z.number().int().nonnegative(),
+        }),
+    })),
+    Report: z.object({
+        Linters: z
+            .array(z.object({ Name: z.string(), Enabled: z.boolean().optional() }))
+            .optional(),
+        Warnings: z.array(z.unknown()).optional(),
+        Error: z.string().optional(),
+    }),
+});
+export function golangciEvidence(check, processes, root) {
+    const incomplete = {
+        status: "inconclusive",
+        reason: "golangci-lint evidence, active linters or native Go scope could not be established.",
+    };
+    if (!root || processes.length !== 2)
+        return incomplete;
+    const process = processes[1];
+    if (![0, 1].includes(process.exitCode ?? -1))
+        return {
+            status: "error",
+            reason: "golangci-lint configuration or its supported execution profile could not run.",
+        };
+    try {
+        const report = schema.parse(JSON.parse(process.stdout));
+        const expected = new Set(check.scope.map((file) => path.resolve(root, check.project, file)));
+        const active = report.Report.Linters?.filter((linter) => linter.Enabled).map((linter) => linter.Name) ?? [];
+        if (!active.some((name) => name !== "typecheck") ||
+            new Set(active).size !== active.length ||
+            active.some((name) => ![
+                "errcheck",
+                "govet",
+                "ineffassign",
+                "staticcheck",
+                "unused",
+                "typecheck",
+            ].includes(name)))
+            return incomplete;
+        if (report.Issues.some((issue) => !path.isAbsolute(issue.Pos.Filename) ||
+            !expected.has(path.resolve(issue.Pos.Filename))))
+            return incomplete;
+        const findings = report.Issues.map((issue) => ({
+            ruleId: issue.FromLinter,
+            level: "error",
+            message: issue.Text,
+            file: path.relative(root, issue.Pos.Filename).split(path.sep).join("/"),
+            line: issue.Pos.Line,
+        }));
+        if (findings.length)
+            return {
+                status: "failed",
+                reason: "golangci-lint reported native diagnostics.",
+                findings,
+                findingsComplete: process.exitCode === 1 &&
+                    !process.stderr.trim() &&
+                    !report.Report.Error &&
+                    !report.Report.Warnings?.length &&
+                    report.Issues.every((issue) => issue.FromLinter !== "typecheck" &&
+                        active.includes(issue.FromLinter)) &&
+                    goScopeComplete(check, processes[0], root),
+            };
+        if (process.exitCode !== 0 || report.Report.Error)
+            return {
+                status: "error",
+                reason: "golangci-lint reported an analysis or loading error.",
+            };
+        if (report.Report.Warnings?.length ||
+            process.stderr.trim() ||
+            !goScopeComplete(check, processes[0], root))
+            return incomplete;
+        return {
+            status: "passed",
+            reason: "Configured golangci-lint checks completed for the inventoried Go scope.",
+            findings,
+            findingsComplete: true,
+        };
+    }
+    catch {
+        return incomplete;
+    }
+}

package/dist/src/golangci-runner.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/golangci-runner.js

@@ -0,0 +1,124 @@
+import { spawnSync } from "node:child_process";
+import { mkdtemp, writeFile, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import { parseDocument } from "yaml";
+import { z } from "zod";
+import { readProjectFile } from "./inventory.js";
+import { hasGoSuppression } from "./go-directives.js";
+const supported = z.enum([
+    "errcheck",
+    "govet",
+    "ineffassign",
+    "staticcheck",
+    "unused",
+]);
+const configuration = z.strictObject({
+    version: z.literal("2"),
+    linters: z
+        .strictObject({
+        default: z.enum(["standard", "none"]).optional(),
+        enable: z.array(supported).optional(),
+        disable: z.array(supported).optional(),
+        settings: z.record(z.string(), z.unknown()).optional(),
+        exclusions: z.record(z.string(), z.unknown()).optional(),
+    })
+        .optional(),
+    run: z.record(z.string(), z.unknown()).optional(),
+    issues: z.record(z.string(), z.unknown()).optional(),
+    output: z.record(z.string(), z.unknown()).optional(),
+    severity: z.record(z.string(), z.unknown()).optional(),
+    formatters: z.record(z.string(), z.unknown()).optional(),
+});
+async function main() {
+    const [root, configFile, ...files] = process.argv.slice(2);
+    if (!root || !configFile || !files.length)
+        throw new Error("Invalid golangci-lint arguments");
+    const version = spawnSync("golangci-lint", ["version", "--short"], {
+        encoding: "utf8",
+        maxBuffer: 8192,
+    });
+    if (version.error ||
+        version.status !== 0 ||
+        version.stderr.trim() ||
+        version.stdout.trim() !== "2.13.2")
+        throw new Error("golangci-lint integration requires installed verified version 2.13.2");
+    const raw = await readProjectFile(root, path.relative(root, path.resolve(configFile)));
+    const document = parseDocument(raw, { uniqueKeys: true });
+    if (document.errors.length || document.warnings.length)
+        throw new Error("Invalid golangci-lint configuration");
+    const config = configuration.parse(document.toJS({ maxAliasCount: 50 }));
+    if (Object.keys(config.linters?.settings ?? {}).length ||
+        Object.keys(config.formatters ?? {}).length ||
+        Object.hasOwn(config.run ?? {}, "go") ||
+        Object.hasOwn(config.run ?? {}, "build-tags"))
+        throw new Error("Custom linter settings, formatters and Go build profiles need separately verified integration");
+    for (const file of files)
+        if (hasGoSuppression(await readProjectFile(root, path.relative(root, path.resolve(file)))))
+            throw new Error("Native Go suppression directives prevent complete golangci-lint evidence");
+    const temporary = await mkdtemp(path.join(tmpdir(), "checktrail-golangci-"));
+    try {
+        const target = path.join(temporary, "config.json");
+        const native = {
+            version: "2",
+            run: {
+                tests: true,
+                "modules-download-mode": "readonly",
+                "relative-path-mode": "wd",
+                "issues-exit-code": 1,
+                "allow-parallel-runners": true,
+                "enable-build-vcs": false,
+            },
+            linters: {
+                ...config.linters,
+                settings: {},
+                exclusions: {
+                    generated: "disable",
+                    presets: [],
+                    rules: [],
+                    paths: [],
+                    "paths-except": [],
+                },
+            },
+            issues: {
+                fix: false,
+                new: false,
+                "new-from-rev": "",
+                "new-from-merge-base": "",
+                "new-from-patch": "",
+                "max-issues-per-linter": 0,
+                "max-same-issues": 0,
+                "uniq-by-line": false,
+            },
+            output: {
+                formats: { json: { path: "stdout" } },
+                "show-stats": false,
+                "path-mode": "abs",
+                "path-prefix": "",
+            },
+        };
+        await writeFile(target, JSON.stringify(native));
+        const result = spawnSync("golangci-lint", ["run", "--config", target, "--color", "never", "./..."], {
+            encoding: "utf8",
+            maxBuffer: 1024 * 1024,
+            env: {
+                ...process.env,
+                GOLANGCI_LINT_CACHE: path.join(temporary, "cache"),
+            },
+        });
+        if (result.error)
+            throw result.error;
+        process.stdout.write(result.stdout);
+        process.stderr.write(result.stderr);
+        process.exitCode = result.status ?? 2;
+    }
+    finally {
+        await rm(temporary, { recursive: true, force: true });
+    }
+}
+main().catch((error) => {
+    process.stderr.write((error instanceof Error
+        ? error.message
+        : "golangci-lint execution failed") + "\n");
+    process.exitCode = 2;
+});

package/dist/src/golangci.d.ts

@@ -0,0 +1,2 @@
+import type { Check, Inventory, Project } from "./types.js";
+export declare function golangciCheck(source: Inventory, project: Project): Promise<Check>;

package/dist/src/golangci.js

@@ -0,0 +1,35 @@
+import { fileURLToPath } from "node:url";
+import { goEnvironment, goScopeCommand } from "./go-scope.js";
+export async function golangciCheck(source, project) {
+    const configs = project.files.filter((file) => /^\.golangci\.(?:ya?ml|json)$/.test(file));
+    const files = project.files.filter((file) => file.endsWith(".go"));
+    const check = {
+        id: "go.golangci-lint",
+        adapter: project.adapter,
+        project: project.path,
+        scope: files,
+        kind: "analysis",
+        parser: "golangci-json",
+        reason: "Run configured supported golangci-lint checks with native Go scope, unfiltered JSON evidence and fixes disabled.",
+        commands: [
+            goScopeCommand(project.path),
+            {
+                executable: process.execPath,
+                args: [
+                    fileURLToPath(new URL("./golangci-runner.js", import.meta.url)),
+                    source.root,
+                    configs[0] ?? "",
+                    ...files,
+                ],
+                cwd: project.path,
+                env: goEnvironment,
+            },
+        ],
+    };
+    if (configs.length !== 1)
+        check.unavailableReason =
+            "Exactly one project-local .golangci.yml, .yaml or .json is required.";
+    else if (!files.length)
+        check.unavailableReason = "No Go source was inventoried.";
+    return check;
+}

package/dist/src/guidance.d.ts

@@ -0,0 +1,98 @@
+import { z } from "zod";
+export declare const guidanceTopicSchema: z.ZodEnum<{
+    "test-lifecycle": "test-lifecycle";
+    "analysis-scope": "analysis-scope";
+    "package-consumers": "package-consumers";
+    "python-imports": "python-imports";
+    "framework-assembly": "framework-assembly";
+    "execution-depth": "execution-depth";
+}>;
+export declare const guidanceContextSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<1>;
+    checks: z.ZodArray<z.ZodString>;
+    topics: z.ZodArray<z.ZodEnum<{
+        "test-lifecycle": "test-lifecycle";
+        "analysis-scope": "analysis-scope";
+        "package-consumers": "package-consumers";
+        "python-imports": "python-imports";
+        "framework-assembly": "framework-assembly";
+        "execution-depth": "execution-depth";
+    }>>;
+}, z.core.$strict>;
+export declare const guidanceReportSchema: z.ZodObject<{
+    context: z.ZodObject<{
+        schemaVersion: z.ZodLiteral<1>;
+        checks: z.ZodArray<z.ZodString>;
+        topics: z.ZodArray<z.ZodEnum<{
+            "test-lifecycle": "test-lifecycle";
+            "analysis-scope": "analysis-scope";
+            "package-consumers": "package-consumers";
+            "python-imports": "python-imports";
+            "framework-assembly": "framework-assembly";
+            "execution-depth": "execution-depth";
+        }>>;
+    }, z.core.$strict>;
+    items: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        version: z.ZodLiteral<"1.0.0">;
+        title: z.ZodString;
+        triggers: z.ZodObject<{
+            checks: z.ZodArray<z.ZodString>;
+            topics: z.ZodArray<z.ZodEnum<{
+                "test-lifecycle": "test-lifecycle";
+                "analysis-scope": "analysis-scope";
+                "package-consumers": "package-consumers";
+                "python-imports": "python-imports";
+                "framework-assembly": "framework-assembly";
+                "execution-depth": "execution-depth";
+            }>>;
+        }, z.core.$strict>;
+        questions: z.ZodArray<z.ZodString>;
+        references: z.ZodArray<z.ZodObject<{
+            title: z.ZodString;
+            url: z.ZodURL;
+        }, z.core.$strict>>;
+        matched: z.ZodObject<{
+            schemaVersion: z.ZodLiteral<1>;
+            checks: z.ZodArray<z.ZodString>;
+            topics: z.ZodArray<z.ZodEnum<{
+                "test-lifecycle": "test-lifecycle";
+                "analysis-scope": "analysis-scope";
+                "package-consumers": "package-consumers";
+                "python-imports": "python-imports";
+                "framework-assembly": "framework-assembly";
+                "execution-depth": "execution-depth";
+            }>>;
+        }, z.core.$strict>;
+    }, z.core.$strict>>;
+    schemaVersion: z.ZodLiteral<1>;
+    engineVersion: z.ZodString;
+    channel: z.ZodLiteral<"advisory">;
+    provenance: z.ZodLiteral<"builtin-guidance-selection">;
+    catalogueDigest: z.ZodString;
+    automatedCoverage: z.ZodLiteral<false>;
+    selectionBasis: z.ZodLiteral<"exact-check-or-topic">;
+}, z.core.$strict>;
+export declare const guidanceSummarySchema: z.ZodObject<{
+    items: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        version: z.ZodLiteral<"1.0.0">;
+        references: z.ZodArray<z.ZodObject<{
+            title: z.ZodString;
+            url: z.ZodURL;
+        }, z.core.$strict>>;
+        title: z.ZodString;
+        questions: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>>;
+    schemaVersion: z.ZodLiteral<1>;
+    engineVersion: z.ZodString;
+    channel: z.ZodLiteral<"advisory">;
+    provenance: z.ZodLiteral<"builtin-guidance-selection">;
+    catalogueDigest: z.ZodString;
+    automatedCoverage: z.ZodLiteral<false>;
+    selectionBasis: z.ZodLiteral<"exact-check-or-topic">;
+}, z.core.$strict>;
+export type GuidanceContext = z.infer<typeof guidanceContextSchema>;
+export type GuidanceReport = z.infer<typeof guidanceReportSchema>;
+export declare function retrieveGuidance(input: unknown): GuidanceReport;
+export declare function projectGuidance(report: GuidanceReport, detailed: boolean): Record<string, unknown>;

package/dist/src/guidance.js

@@ -0,0 +1,247 @@
+import { createHash } from "node:crypto";
+import { z } from "zod";
+import { VERSION } from "./types.js";
+export const guidanceTopicSchema = z.enum([
+    "test-lifecycle",
+    "analysis-scope",
+    "package-consumers",
+    "python-imports",
+    "framework-assembly",
+    "execution-depth",
+]);
+const identifier = z
+    .string()
+    .min(1)
+    .max(128)
+    .regex(/^[a-z0-9][a-z0-9.-]*$/);
+const digest = z.string().regex(/^[a-f0-9]{64}$/);
+export const guidanceContextSchema = z.strictObject({
+    schemaVersion: z.literal(1),
+    checks: z.array(identifier).max(100),
+    topics: z.array(guidanceTopicSchema).max(16),
+});
+const referenceSchema = z.strictObject({
+    title: z.string().min(1).max(160),
+    url: z
+        .url()
+        .regex(/^https:\/\//)
+        .max(512)
+        .meta({ format: "uri" }),
+});
+const itemSchema = z.strictObject({
+    id: identifier,
+    version: z.literal("1.0.0"),
+    title: z.string().min(1).max(160),
+    triggers: z.strictObject({
+        checks: z.array(identifier).max(32),
+        topics: z.array(guidanceTopicSchema).min(1).max(16),
+    }),
+    questions: z.array(z.string().min(1).max(600)).min(1).max(8),
+    references: z.array(referenceSchema).min(1).max(8),
+});
+const catalogue = z
+    .array(itemSchema)
+    .max(64)
+    .parse([
+    {
+        id: "review.test-lifecycle",
+        version: "1.0.0",
+        title: "Await asynchronous work and release test resources",
+        triggers: {
+            checks: ["javascript.node-test"],
+            topics: ["test-lifecycle"],
+        },
+        questions: [
+            "Does each asynchronous assertion finish before its test completes, including assertions inside subtests and callbacks?",
+            "Are timers, mocks and open handles released when an assertion throws, and does running the test alongside its siblings preserve the result?",
+        ],
+        references: [
+            {
+                title: "Node.js test runner",
+                url: "https://nodejs.org/api/test.html",
+            },
+        ],
+    },
+    {
+        id: "review.analysis-scope",
+        version: "1.0.0",
+        title: "Check the files selected by analysis configuration",
+        triggers: {
+            checks: ["javascript.eslint"],
+            topics: ["analysis-scope"],
+        },
+        questions: [
+            "Which source files does the resolved lint configuration select, and which files does it intentionally ignore?",
+            "Do changed file extensions and nested packages appear in the tool's observed scope, with any exclusions reviewed explicitly?",
+        ],
+        references: [
+            {
+                title: "ESLint ignore configuration",
+                url: "https://eslint.org/docs/latest/use/configure/ignore",
+            },
+        ],
+    },
+    {
+        id: "review.package-consumers",
+        version: "1.0.0",
+        title: "Exercise the package consumed after a build",
+        triggers: {
+            checks: ["javascript.typescript-build"],
+            topics: ["package-consumers"],
+        },
+        questions: [
+            "Does a consumer resolve the freshly built declarations and runtime entry points that will actually be distributed?",
+            "Would both the consumer type check and its runtime test detect a producer interface change, including a declaration that disagrees with emitted JavaScript?",
+        ],
+        references: [
+            {
+                title: "TypeScript project references",
+                url: "https://www.typescriptlang.org/docs/handbook/project-references.html",
+            },
+        ],
+    },
+    {
+        id: "review.python-imports",
+        version: "1.0.0",
+        title: "Establish which Python package tests import",
+        triggers: {
+            checks: ["python.pytest"],
+            topics: ["python-imports"],
+        },
+        questions: [
+            "Does the import mode exercise the intended installed package or source checkout, and is that choice recorded?",
+            "Can the distribution's public imports be exercised in a clean environment without relying on the working directory being on the import path?",
+        ],
+        references: [
+            {
+                title: "pytest integration practices",
+                url: "https://docs.pytest.org/en/stable/explanation/goodpractices.html",
+            },
+        ],
+    },
+    {
+        id: "review.framework-assembly",
+        version: "1.0.0",
+        title: "Compare the supported runtime assembly projection",
+        triggers: {
+            checks: [
+                "php.laravel-runtime",
+                "javascript.vue-router",
+                "javascript.nuxt-runtime",
+                "python.fastapi-routes",
+                "python.django-routes",
+            ],
+            topics: ["framework-assembly"],
+        },
+        questions: [
+            "Were both inventories captured after the required startup phase, using compatible collectors and the intended test environment?",
+            "Which registration, multiplicity or ordering changes are expected, and which application decisions need separate request-level tests beyond this collector's projection?",
+        ],
+        references: [
+            {
+                title: "Laravel routing",
+                url: "https://laravel.com/docs/13.x/routing",
+            },
+        ],
+    },
+    {
+        id: "review.execution-depth",
+        version: "1.0.0",
+        title: "Distinguish parsing and compilation from executed behavior",
+        triggers: {
+            checks: [
+                "php.syntax",
+                "ruby.syntax",
+                "swift.syntax",
+                "rust.cargo-check",
+            ],
+            topics: ["execution-depth"],
+        },
+        questions: [
+            "What does the selected native command establish: grammar, types, linking or executed tests?",
+            "Which behavioral assertions still need to run after parsing or compilation succeeds, and is unavailable test execution visible in the review?",
+        ],
+        references: [
+            {
+                title: "Cargo check command",
+                url: "https://doc.rust-lang.org/cargo/commands/cargo-check.html",
+            },
+        ],
+    },
+]);
+const catalogueDigest = createHash("sha256")
+    .update(JSON.stringify(catalogue))
+    .digest("hex");
+const metadata = {
+    schemaVersion: z.literal(1),
+    engineVersion: z.string(),
+    channel: z.literal("advisory"),
+    provenance: z.literal("builtin-guidance-selection"),
+    catalogueDigest: digest,
+    automatedCoverage: z.literal(false),
+    selectionBasis: z.literal("exact-check-or-topic"),
+};
+export const guidanceReportSchema = z.strictObject({
+    ...metadata,
+    context: guidanceContextSchema,
+    items: z.array(itemSchema.extend({ matched: guidanceContextSchema })).max(64),
+});
+export const guidanceSummarySchema = z.strictObject({
+    ...metadata,
+    items: z.array(itemSchema.omit({ triggers: true })).max(64),
+});
+export function retrieveGuidance(input) {
+    const serialized = JSON.stringify(input);
+    if (serialized === undefined || Buffer.byteLength(serialized) > 16_384)
+        throw new Error("Guidance context exceeds input limits");
+    const context = guidanceContextSchema.parse(input);
+    for (const values of [context.checks, context.topics])
+        if (new Set(values).size !== values.length)
+            throw new Error("Guidance context identifiers must be unique");
+    context.checks.sort();
+    context.topics.sort();
+    const checks = new Set(context.checks);
+    const topics = new Set(context.topics);
+    const items = catalogue.flatMap((item) => {
+        const matched = {
+            schemaVersion: 1,
+            checks: item.triggers.checks.filter((check) => checks.has(check)),
+            topics: item.triggers.topics.filter((topic) => topics.has(topic)),
+        };
+        return matched.checks.length || matched.topics.length
+            ? [{ ...item, matched }]
+            : [];
+    });
+    return guidanceReportSchema.parse({
+        schemaVersion: 1,
+        engineVersion: VERSION,
+        channel: "advisory",
+        provenance: "builtin-guidance-selection",
+        catalogueDigest,
+        automatedCoverage: false,
+        selectionBasis: "exact-check-or-topic",
+        context,
+        items,
+    });
+}
+export function projectGuidance(report, detailed) {
+    const parsed = guidanceReportSchema.parse(report);
+    if (detailed)
+        return parsed;
+    return guidanceSummarySchema.parse({
+        schemaVersion: parsed.schemaVersion,
+        engineVersion: parsed.engineVersion,
+        channel: parsed.channel,
+        provenance: parsed.provenance,
+        catalogueDigest: parsed.catalogueDigest,
+        automatedCoverage: parsed.automatedCoverage,
+        selectionBasis: parsed.selectionBasis,
+        items: parsed.items.map((item) => ({
+            id: item.id,
+            version: item.version,
+            title: item.title,
+            questions: item.questions,
+            references: item.references,
+        })),
+    });
+}

package/dist/src/index.d.ts

@@ -0,0 +1,31 @@
+export { createPlan, validate, aggregate } from "./engine.js";
+export { validateContracts } from "./contracts.js";
+export type { ContractBundle, ContractReport } from "./contract-schema.js";
+export type { PlanOptions, ValidationOptions } from "./engine.js";
+export { adapters } from "./adapters.js";
+export type { PolicyPack, PackReference } from "./policy-pack.js";
+export { fetchPolicyPack } from "./fetch-pack.js";
+export type { FetchPackOptions, FetchedPack } from "./fetch-pack.js";
+export { projectPlan, projectReport } from "./output.js";
+export type { Plan, Report, Check, CheckResult, Status, Outcome, TestEvidence, ToolSpec, ToolEvidence, Finding, Workspace, GitIdentity, ChangeSelection, } from "./types.js";
+export { importJUnit } from "./junit.js";
+export type { JUnitImport, JUnitCase } from "./junit.js";
+export { exportSarif } from "./sarif.js";
+export { createFindingBaseline, compareFindings } from "./finding-policy.js";
+export { compareRuntimeInventories } from "./runtime-inventory.js";
+export type { RuntimeInventory, RuntimeComparison, } from "./runtime-inventory.js";
+export type { FindingBaseline, FindingComparison, } from "./finding-policy-schema.js";
+export { checkArchitecture } from "./architecture.js";
+export type { DependencyGraph, ArchitecturePolicy, ArchitectureReport, } from "./architecture.js";
+export { retrieveGuidance, projectGuidance } from "./guidance.js";
+export type { GuidanceContext, GuidanceReport } from "./guidance.js";
+export { runMutations, projectMutations } from "./mutation.js";
+export type { MutationRecipe, MutationReport } from "./mutation.js";
+export { loadExternalAdapters } from "./external-adapter.js";
+export type { ExternalReference, ExternalIdentity, } from "./external-adapter.js";
+export { createReviewContext, projectReviewContext, receiveReview, projectReviewReceipt, } from "./review.js";
+export type { ReviewContext, ReviewAssessment, ReviewReceipt, } from "./review.js";
+export { openTaskStore } from "./task-store.js";
+export type { ValidationTaskStore, StoredValidationTask, TaskStoreOptions, TaskTransition, } from "./task-store.js";
+export { openValidationTasks } from "./validation-tasks.js";
+export type { ValidationTasks, ValidationTasksOptions, } from "./validation-tasks.js";

package/dist/src/index.js

@@ -0,0 +1,16 @@
+export { createPlan, validate, aggregate } from "./engine.js";
+export { validateContracts } from "./contracts.js";
+export { adapters } from "./adapters.js";
+export { fetchPolicyPack } from "./fetch-pack.js";
+export { projectPlan, projectReport } from "./output.js";
+export { importJUnit } from "./junit.js";
+export { exportSarif } from "./sarif.js";
+export { createFindingBaseline, compareFindings } from "./finding-policy.js";
+export { compareRuntimeInventories } from "./runtime-inventory.js";
+export { checkArchitecture } from "./architecture.js";
+export { retrieveGuidance, projectGuidance } from "./guidance.js";
+export { runMutations, projectMutations } from "./mutation.js";
+export { loadExternalAdapters } from "./external-adapter.js";
+export { createReviewContext, projectReviewContext, receiveReview, projectReviewReceipt, } from "./review.js";
+export { openTaskStore } from "./task-store.js";
+export { openValidationTasks } from "./validation-tasks.js";

package/dist/src/inventory.d.ts

@@ -0,0 +1,4 @@
+import type { Inventory } from "./types.js";
+export declare function withinRoot(root: string, relative: string): Promise<string>;
+export declare function readProjectFile(root: string, relative: string): Promise<string>;
+export declare function inventory(inputRoot: string): Promise<Inventory>;