@codapult/guard 0.1.0

package/dist/core/history/history.d.ts

@@ -0,0 +1,24 @@
+export interface GuardSnapshotSummary {
+    revision: string;
+    path: string;
+    files: number;
+    modules: number;
+    capabilities: string[];
+    cycles: number;
+}
+export interface GuardHistoryDiff {
+    from: string;
+    to: string;
+    addedFiles: string[];
+    removedFiles: string[];
+    addedDependencies: string[];
+    removedDependencies: string[];
+    addedCapabilities: string[];
+    removedCapabilities: string[];
+    cycles: {
+        from: number;
+        to: number;
+    };
+}
+export declare function listGuardSnapshots(root: string): GuardSnapshotSummary[];
+export declare function diffGuardSnapshots(root: string, from: string, to: string): GuardHistoryDiff | undefined;

package/dist/core/history/history.js

@@ -0,0 +1,65 @@
+import { existsSync, readdirSync, readFileSync } from 'node:fs';
+import { resolve } from 'node:path';
+import { GUARD_HISTORY_DIR } from '../guard.js';
+function readSnapshot(root, revision) {
+    if (!/^[A-Za-z0-9._-]+$/.test(revision))
+        return undefined;
+    try {
+        return JSON.parse(readFileSync(resolve(root, GUARD_HISTORY_DIR, `${revision}.json`), 'utf8'));
+    }
+    catch {
+        return undefined;
+    }
+}
+export function listGuardSnapshots(root) {
+    const directory = resolve(root, GUARD_HISTORY_DIR);
+    if (!existsSync(directory))
+        return [];
+    return readdirSync(directory)
+        .filter((file) => file.endsWith('.json'))
+        .sort()
+        .flatMap((file) => {
+        const revision = file.slice(0, -5);
+        const model = readSnapshot(root, revision);
+        return model
+            ? [
+                {
+                    revision,
+                    path: `${GUARD_HISTORY_DIR}/${file}`,
+                    files: model.files.length,
+                    modules: model.modules.length,
+                    capabilities: Object.keys(model.capabilities).sort(),
+                    cycles: model.insights.cycles.length,
+                },
+            ]
+            : [];
+    });
+}
+export function diffGuardSnapshots(root, from, to) {
+    const before = readSnapshot(root, from);
+    const after = readSnapshot(root, to);
+    if (!before || !after)
+        return undefined;
+    const difference = (left, right) => right.filter((value) => !left.includes(value)).sort();
+    const beforeFiles = before.files.map((file) => file.path);
+    const afterFiles = after.files.map((file) => file.path);
+    const beforeDependencies = Object.keys({
+        ...before.project.dependencies,
+        ...before.project.devDependencies,
+    });
+    const afterDependencies = Object.keys({
+        ...after.project.dependencies,
+        ...after.project.devDependencies,
+    });
+    return {
+        from,
+        to,
+        addedFiles: difference(beforeFiles, afterFiles),
+        removedFiles: difference(afterFiles, beforeFiles),
+        addedDependencies: difference(beforeDependencies, afterDependencies),
+        removedDependencies: difference(afterDependencies, beforeDependencies),
+        addedCapabilities: difference(Object.keys(before.capabilities), Object.keys(after.capabilities)),
+        removedCapabilities: difference(Object.keys(after.capabilities), Object.keys(before.capabilities)),
+        cycles: { from: before.insights.cycles.length, to: after.insights.cycles.length },
+    };
+}

package/dist/core/output/sarif.d.ts

@@ -0,0 +1,35 @@
+import type { GuardFinding } from '../guard.js';
+interface SarifResult {
+    ruleId: string;
+    level: 'error' | 'warning' | 'note';
+    message: {
+        text: string;
+    };
+    locations: [
+        {
+            physicalLocation: {
+                artifactLocation: {
+                    uri: string;
+                };
+                region: {
+                    startLine: number;
+                };
+            };
+        }
+    ];
+}
+export interface SarifLog {
+    version: '2.1.0';
+    $schema: string;
+    runs: [{
+        tool: {
+            driver: {
+                name: string;
+                informationUri: string;
+            };
+        };
+        results: SarifResult[];
+    }];
+}
+export declare function guardFindingsToSarif(findings: GuardFinding[]): SarifLog;
+export {};

package/dist/core/output/sarif.js

@@ -0,0 +1,29 @@
+export function guardFindingsToSarif(findings) {
+    return {
+        version: '2.1.0',
+        $schema: 'https://json.schemastore.org/sarif-2.1.0.json',
+        runs: [
+            {
+                tool: {
+                    driver: {
+                        name: 'Codapult Guard',
+                        informationUri: 'https://codapult.dev/docs/developer-tools/guard',
+                    },
+                },
+                results: findings.map((finding) => ({
+                    ruleId: finding.ruleId,
+                    level: finding.severity === 'info' ? 'note' : finding.severity,
+                    message: { text: finding.message },
+                    locations: [
+                        {
+                            physicalLocation: {
+                                artifactLocation: { uri: finding.file },
+                                region: { startLine: finding.line },
+                            },
+                        },
+                    ],
+                })),
+            },
+        ],
+    };
+}

package/dist/core/policy/schemas.d.ts

@@ -0,0 +1,272 @@
+import { z } from 'zod';
+export declare const guardRuleSchema: z.ZodObject<{
+    id: z.ZodString;
+    description: z.ZodString;
+    severity: z.ZodEnum<{
+        error: "error";
+        info: "info";
+        warning: "warning";
+    }>;
+    kind: z.ZodEnum<{
+        "client-forbidden-import": "client-forbidden-import";
+        "forbidden-import": "forbidden-import";
+    }>;
+    patterns: z.ZodArray<z.ZodString>;
+    files: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    status: z.ZodOptional<z.ZodEnum<{
+        active: "active";
+        proposed: "proposed";
+    }>>;
+    confidence: z.ZodOptional<z.ZodEnum<{
+        high: "high";
+        low: "low";
+        medium: "medium";
+    }>>;
+    evidence: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+export declare const guardContractSchema: z.ZodObject<{
+    id: z.ZodString;
+    statement: z.ZodString;
+    kind: z.ZodOptional<z.ZodEnum<{
+        guidance: "guidance";
+        "import-boundary": "import-boundary";
+        "required-call": "required-call";
+    }>>;
+    severity: z.ZodOptional<z.ZodEnum<{
+        error: "error";
+        info: "info";
+        warning: "warning";
+    }>>;
+    scope: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    entrypoints: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    exclude: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    guidance: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    references: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    mustImport: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    mustNotImport: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    mustCall: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    status: z.ZodOptional<z.ZodEnum<{
+        active: "active";
+        proposed: "proposed";
+    }>>;
+    confidence: z.ZodOptional<z.ZodEnum<{
+        high: "high";
+        low: "low";
+        medium: "medium";
+    }>>;
+    evidence: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+export declare const guardConfigSchema: z.ZodObject<{
+    version: z.ZodLiteral<1>;
+    rules: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        description: z.ZodString;
+        severity: z.ZodEnum<{
+            error: "error";
+            info: "info";
+            warning: "warning";
+        }>;
+        kind: z.ZodEnum<{
+            "client-forbidden-import": "client-forbidden-import";
+            "forbidden-import": "forbidden-import";
+        }>;
+        patterns: z.ZodArray<z.ZodString>;
+        files: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        status: z.ZodOptional<z.ZodEnum<{
+            active: "active";
+            proposed: "proposed";
+        }>>;
+        confidence: z.ZodOptional<z.ZodEnum<{
+            high: "high";
+            low: "low";
+            medium: "medium";
+        }>>;
+        evidence: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>;
+    contracts: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        statement: z.ZodString;
+        kind: z.ZodOptional<z.ZodEnum<{
+            guidance: "guidance";
+            "import-boundary": "import-boundary";
+            "required-call": "required-call";
+        }>>;
+        severity: z.ZodOptional<z.ZodEnum<{
+            error: "error";
+            info: "info";
+            warning: "warning";
+        }>>;
+        scope: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        entrypoints: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        exclude: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        guidance: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        references: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        mustImport: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        mustNotImport: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        mustCall: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        status: z.ZodOptional<z.ZodEnum<{
+            active: "active";
+            proposed: "proposed";
+        }>>;
+        confidence: z.ZodOptional<z.ZodEnum<{
+            high: "high";
+            low: "low";
+            medium: "medium";
+        }>>;
+        evidence: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export declare const guardContractsFileSchema: z.ZodObject<{
+    version: z.ZodLiteral<1>;
+    contracts: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        statement: z.ZodString;
+        kind: z.ZodOptional<z.ZodEnum<{
+            guidance: "guidance";
+            "import-boundary": "import-boundary";
+            "required-call": "required-call";
+        }>>;
+        severity: z.ZodOptional<z.ZodEnum<{
+            error: "error";
+            info: "info";
+            warning: "warning";
+        }>>;
+        scope: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        entrypoints: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        exclude: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        guidance: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        references: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        mustImport: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        mustNotImport: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        mustCall: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        status: z.ZodOptional<z.ZodEnum<{
+            active: "active";
+            proposed: "proposed";
+        }>>;
+        confidence: z.ZodOptional<z.ZodEnum<{
+            high: "high";
+            low: "low";
+            medium: "medium";
+        }>>;
+        evidence: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const guardProposalDecisionSchema: z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodEnum<{
+        contract: "contract";
+        rule: "rule";
+    }>;
+    decision: z.ZodEnum<{
+        approved: "approved";
+        rejected: "rejected";
+    }>;
+    decidedAt: z.ZodString;
+    proposalId: z.ZodOptional<z.ZodString>;
+    proposalFingerprint: z.ZodOptional<z.ZodString>;
+    revision: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const guardProposalSchema: z.ZodObject<{
+    version: z.ZodLiteral<1>;
+    generatedAt: z.ZodString;
+    proposalId: z.ZodOptional<z.ZodString>;
+    projectFingerprint: z.ZodOptional<z.ZodString>;
+    revision: z.ZodOptional<z.ZodNumber>;
+    contentFingerprint: z.ZodOptional<z.ZodString>;
+    rules: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        description: z.ZodString;
+        severity: z.ZodEnum<{
+            error: "error";
+            info: "info";
+            warning: "warning";
+        }>;
+        kind: z.ZodEnum<{
+            "client-forbidden-import": "client-forbidden-import";
+            "forbidden-import": "forbidden-import";
+        }>;
+        patterns: z.ZodArray<z.ZodString>;
+        files: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        status: z.ZodOptional<z.ZodEnum<{
+            active: "active";
+            proposed: "proposed";
+        }>>;
+        confidence: z.ZodOptional<z.ZodEnum<{
+            high: "high";
+            low: "low";
+            medium: "medium";
+        }>>;
+        evidence: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>;
+    contracts: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        statement: z.ZodString;
+        kind: z.ZodOptional<z.ZodEnum<{
+            guidance: "guidance";
+            "import-boundary": "import-boundary";
+            "required-call": "required-call";
+        }>>;
+        severity: z.ZodOptional<z.ZodEnum<{
+            error: "error";
+            info: "info";
+            warning: "warning";
+        }>>;
+        scope: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        entrypoints: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        exclude: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        guidance: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        references: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        mustImport: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        mustNotImport: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        mustCall: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        status: z.ZodOptional<z.ZodEnum<{
+            active: "active";
+            proposed: "proposed";
+        }>>;
+        confidence: z.ZodOptional<z.ZodEnum<{
+            high: "high";
+            low: "low";
+            medium: "medium";
+        }>>;
+        evidence: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>;
+    questions: z.ZodArray<z.ZodString>;
+    decisions: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        type: z.ZodEnum<{
+            contract: "contract";
+            rule: "rule";
+        }>;
+        decision: z.ZodEnum<{
+            approved: "approved";
+            rejected: "rejected";
+        }>;
+        decidedAt: z.ZodString;
+        proposalId: z.ZodOptional<z.ZodString>;
+        proposalFingerprint: z.ZodOptional<z.ZodString>;
+        revision: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export declare const guardAgentConfigSchema: z.ZodObject<{
+    version: z.ZodLiteral<1>;
+    tools: z.ZodEnum<{
+        auto: "auto";
+        off: "off";
+        on: "on";
+    }>;
+    tooling: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
+        script: z.ZodString;
+        enabled: z.ZodBoolean;
+    }, z.core.$strip>>>;
+    completionGate: z.ZodObject<{
+        enabled: z.ZodBoolean;
+        maxIterations: z.ZodNumber;
+        projectChecks: z.ZodBoolean;
+        checks: z.ZodArray<z.ZodEnum<{
+            build: "build";
+            lint: "lint";
+            test: "test";
+            typecheck: "typecheck";
+        }>>;
+    }, z.core.$strip>;
+}, z.core.$strip>;

package/dist/core/policy/schemas.js

@@ -0,0 +1,72 @@
+import { z } from 'zod';
+const severity = z.enum(['error', 'warning', 'info']);
+const status = z.enum(['active', 'proposed']);
+export const guardRuleSchema = z.object({
+    id: z.string(),
+    description: z.string(),
+    severity,
+    kind: z.enum(['forbidden-import', 'client-forbidden-import']),
+    patterns: z.array(z.string()),
+    files: z.array(z.string()).optional(),
+    status: status.optional(),
+    confidence: z.enum(['high', 'medium', 'low']).optional(),
+    evidence: z.array(z.string()).optional(),
+});
+export const guardContractSchema = z.object({
+    id: z.string(),
+    statement: z.string(),
+    kind: z.enum(['guidance', 'import-boundary', 'required-call']).optional(),
+    severity: severity.optional(),
+    scope: z.array(z.string()).optional(),
+    entrypoints: z.array(z.string()).optional(),
+    exclude: z.array(z.string()).optional(),
+    guidance: z.array(z.string()).optional(),
+    references: z.array(z.string()).optional(),
+    mustImport: z.array(z.string()).optional(),
+    mustNotImport: z.array(z.string()).optional(),
+    mustCall: z.array(z.string()).optional(),
+    status: status.optional(),
+    confidence: z.enum(['high', 'medium', 'low']).optional(),
+    evidence: z.array(z.string()).optional(),
+});
+export const guardConfigSchema = z.object({
+    version: z.literal(1),
+    rules: z.array(guardRuleSchema),
+    contracts: z.array(guardContractSchema).optional(),
+});
+export const guardContractsFileSchema = z.object({
+    version: z.literal(1),
+    contracts: z.array(guardContractSchema),
+});
+export const guardProposalDecisionSchema = z.object({
+    id: z.string(),
+    type: z.enum(['rule', 'contract']),
+    decision: z.enum(['approved', 'rejected']),
+    decidedAt: z.string(),
+    proposalId: z.string().optional(),
+    proposalFingerprint: z.string().optional(),
+    revision: z.number().optional(),
+});
+export const guardProposalSchema = z.object({
+    version: z.literal(1),
+    generatedAt: z.string(),
+    proposalId: z.string().optional(),
+    projectFingerprint: z.string().optional(),
+    revision: z.number().int().positive().optional(),
+    contentFingerprint: z.string().optional(),
+    rules: z.array(guardRuleSchema),
+    contracts: z.array(guardContractSchema),
+    questions: z.array(z.string()),
+    decisions: z.array(guardProposalDecisionSchema).optional(),
+});
+export const guardAgentConfigSchema = z.object({
+    version: z.literal(1),
+    tools: z.enum(['auto', 'on', 'off']),
+    tooling: z.record(z.string(), z.object({ script: z.string(), enabled: z.boolean() })).default({}),
+    completionGate: z.object({
+        enabled: z.boolean(),
+        maxIterations: z.number().int().min(1).max(10),
+        projectChecks: z.boolean(),
+        checks: z.array(z.enum(['lint', 'typecheck', 'test', 'build'])),
+    }),
+});

package/dist/core/verification/verify.d.ts

@@ -0,0 +1,29 @@
+import { type CommandResult } from '../../adapters/command.js';
+import { type GuardAdapter, type ProjectCheck, type ProjectCheckResults, type ProjectRuntimeDiagnostics } from '../../adapters/project-checks.js';
+import { type GuardToolMode, type GuardContractIssue, type GuardReport } from '../guard.js';
+export type GuardVerificationCheck = ProjectCheck;
+export interface GuardVerificationResult {
+    status: 'ok' | 'fail' | 'not-configured';
+    outcome: 'pass' | 'fail' | 'warning' | 'needs-review' | 'not-configured';
+    tools?: GuardToolMode;
+    checks: ProjectCheckResults;
+    workspaceChecks: Record<string, ProjectCheckResults>;
+    adapters: Partial<Record<GuardAdapter, CommandResult>>;
+    runtime: ProjectRuntimeDiagnostics;
+    architecture?: GuardReport;
+    contractIssues: GuardContractIssue[];
+    requirement: {
+        status: 'delegated-to-review';
+        provided: boolean;
+        message: string;
+    };
+}
+export declare function runGuardVerification(root: string, options?: {
+    checks?: GuardVerificationCheck[];
+    changedOnly?: boolean;
+    timeout?: number;
+    requirement?: string;
+    tools?: GuardToolMode;
+    strict?: boolean;
+    projectChecks?: boolean;
+}): GuardVerificationResult;

package/dist/core/verification/verify.js

@@ -0,0 +1,77 @@
+import { runProjectAdapters, runProjectChecks, runWorkspaceProjectChecks, inspectProjectRuntime, } from '../../adapters/project-checks.js';
+import { loadBaseline, loadGuardAgentConfig, loadGuardConfig, scanGuard, classifyGuardOutcome, validateGuardContracts, } from '../guard.js';
+import { discoverProject } from '../discovery/discovery.js';
+export function runGuardVerification(root, options = {}) {
+    const config = loadGuardConfig(root);
+    const requirement = {
+        status: 'delegated-to-review',
+        provided: Boolean(options.requirement?.trim()),
+        message: options.requirement?.trim()
+            ? 'Requirement text is included in semantic review input; deterministic verify does not judge natural-language acceptance criteria.'
+            : 'Requirement satisfaction is evaluated by guard review using the task and diff.',
+    };
+    const runtime = inspectProjectRuntime(root);
+    if (!config)
+        return {
+            status: 'not-configured',
+            outcome: 'not-configured',
+            checks: {},
+            workspaceChecks: {},
+            adapters: {},
+            runtime,
+            contractIssues: [],
+            requirement,
+        };
+    const agentConfig = loadGuardAgentConfig(root);
+    const projectChecks = options.projectChecks ?? agentConfig.completionGate.projectChecks;
+    const checks = projectChecks ? (options.checks ?? agentConfig.completionGate.checks) : [];
+    const results = runProjectChecks(root, checks, { timeout: options.timeout });
+    const workspaceModel = discoverProject(root);
+    const workspaceChecks = runWorkspaceProjectChecks(root, workspaceModel.project.workspacePackages ?? [], checks, {
+        timeout: options.timeout,
+        rootResults: results,
+    });
+    const toolMode = options.tools ?? agentConfig.tools;
+    const adapters = toolMode === 'off'
+        ? {}
+        : runProjectAdapters(root, {
+            mode: toolMode,
+            timeout: options.timeout,
+            tooling: agentConfig.tooling,
+        });
+    const architecture = scanGuard(root, config, {
+        changedOnly: options.changedOnly,
+        baseline: loadBaseline(root),
+        includeArchitectureInsights: true,
+    });
+    const contractIssues = validateGuardContracts(root, config.contracts ?? []);
+    const commandFailed = Object.values(results).some((result) => result.status === 'failed');
+    const workspaceCommandFailed = Object.values(workspaceChecks).some((packageResults) => Object.values(packageResults).some((result) => result.status === 'failed'));
+    const adapterFailed = Object.values(adapters).some((result) => result.status === 'failed');
+    const missingRequiredTools = options.strict &&
+        [...Object.values(results), ...Object.values(adapters)].some((result) => result.status === 'not-configured');
+    const architectureFailed = architecture.findings.some((finding) => finding.severity === 'error');
+    const architectureWarnings = architecture.findings.some((finding) => finding.severity === 'warning');
+    const failed = (projectChecks && !runtime.compatible) ||
+        commandFailed ||
+        workspaceCommandFailed ||
+        adapterFailed ||
+        architectureFailed ||
+        contractIssues.length > 0 ||
+        missingRequiredTools;
+    return {
+        status: failed ? 'fail' : 'ok',
+        outcome: classifyGuardOutcome({
+            errors: failed ? 1 : 0,
+            warnings: architectureWarnings ? 1 : 0,
+        }),
+        tools: toolMode,
+        checks: results,
+        workspaceChecks,
+        adapters,
+        runtime,
+        architecture,
+        contractIssues,
+        requirement,
+    };
+}

package/dist/index.d.ts

@@ -0,0 +1,10 @@
+/** Public, framework-agnostic Guard API. */
+export * from './core/guard.js';
+export * from './core/discovery/discovery.js';
+export { runGuardVerification } from './core/verification/verify.js';
+export type { GuardVerificationCheck, GuardVerificationResult, } from './core/verification/verify.js';
+export * from './core/history/history.js';
+export * from './core/output/sarif.js';
+export * from './core/analysis/doctor.js';
+export * from './core/analysis/packs.js';
+export * from './adapters/project-checks.js';

package/dist/index.js

@@ -0,0 +1,9 @@
+/** Public, framework-agnostic Guard API. */
+export * from './core/guard.js';
+export * from './core/discovery/discovery.js';
+export { runGuardVerification } from './core/verification/verify.js';
+export * from './core/history/history.js';
+export * from './core/output/sarif.js';
+export * from './core/analysis/doctor.js';
+export * from './core/analysis/packs.js';
+export * from './adapters/project-checks.js';

package/dist/mcp/prompts.d.ts

@@ -0,0 +1,2 @@
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+export declare function registerGuardPrompts(server: McpServer): void;