@codapult/guard 0.1.0

package/dist/mcp/prompts.js

@@ -0,0 +1,54 @@
+import { z } from 'zod';
+export function registerGuardPrompts(server) {
+    server.registerPrompt('codapult_guard_proposal_review', {
+        title: 'Guard Proposal Review',
+        description: 'Refine evidence-backed Guard rule and contract proposals before activation.',
+        argsSchema: {
+            proposals: z.string().describe('JSON proposal packet returned by codapult_guard_propose'),
+            focus: z.string().optional().describe('Optional domain focus.'),
+        },
+    }, ({ proposals, focus }) => ({
+        messages: [
+            {
+                role: 'user',
+                content: {
+                    type: 'text',
+                    text: `Review these Guard proposals against project evidence.${focus ? ` Focus on ${focus}.` : ''}
+
+Keep only rules and contracts supported by repeated project evidence. For each proposal, return
+keep/revise/reject, rationale, exact evidence, scope, severity, and unresolved questions. Never
+activate a proposal automatically.
+
+Proposal packet:\n\`\`\`json\n${proposals}\n\`\`\``,
+                },
+            },
+        ],
+    }));
+    server.registerPrompt('codapult_guard_semantic_review', {
+        title: 'Guard Semantic Review',
+        description: 'Review a Guard packet against project-specific contracts and architecture context.',
+        argsSchema: {
+            packet: z.string().describe('JSON review packet returned by codapult_guard_review'),
+            focus: z
+                .string()
+                .optional()
+                .describe('Optional focus such as auth, data access, or API behavior.'),
+        },
+    }, ({ packet, focus }) => ({
+        messages: [
+            {
+                role: 'user',
+                content: {
+                    type: 'text',
+                    text: `Perform an evidence-based semantic architecture review.${focus ? ` Focus on: ${focus}.` : ''}
+
+Treat contracts as project-specific invariants. Do not repeat deterministic findings. Separate
+violations from recommendations and include severity, file, evidence, explanation, and remediation.
+If evidence is insufficient, say so instead of guessing. Do not infer redacted secrets.
+
+Guard packet:\n\`\`\`json\n${packet}\n\`\`\``,
+                },
+            },
+        ],
+    }));
+}

package/dist/mcp/resources.d.ts

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

package/dist/mcp/resources.js

@@ -0,0 +1,64 @@
+import { buildArchitectureMemory, buildConventionsMemory, discoverProject, findGuardRoot, GUARD_ARCHITECTURE_FILE, GUARD_CONVENTIONS_FILE, loadGuardAgentConfig, loadGuardArtifact, loadGuardConfig, loadGuardProposals, } from '../core/guard.js';
+function jsonResource(uri, value) {
+    return {
+        contents: [{ uri, text: JSON.stringify(value, null, 2), mimeType: 'application/json' }],
+    };
+}
+export function registerGuardResources(server) {
+    server.registerResource('codapult_guard_rules', 'codapult://guard/rules', {
+        title: 'Architecture Guard Rules',
+        description: 'Local architecture invariants available to CLI checks and AI agents',
+        mimeType: 'application/json',
+    }, () => {
+        const root = findGuardRoot();
+        const config = loadGuardConfig(root);
+        return jsonResource('codapult://guard/rules', {
+            configured: config !== undefined,
+            rules: config?.rules ?? [],
+            contracts: config?.contracts ?? [],
+            project: discoverProject(root),
+        });
+    });
+    server.registerResource('codapult_guard_context', 'codapult://guard/context', {
+        title: 'Guard Project Context',
+        description: 'Current project model, architecture policy, contracts, and gate settings.',
+        mimeType: 'application/json',
+    }, () => {
+        const root = findGuardRoot();
+        const project = discoverProject(root);
+        const config = loadGuardConfig(root);
+        return jsonResource('codapult://guard/context', {
+            version: 1,
+            root,
+            configured: config !== undefined,
+            project,
+            architecture: loadGuardArtifact(root, GUARD_ARCHITECTURE_FILE) ?? buildArchitectureMemory(project),
+            conventions: loadGuardArtifact(root, GUARD_CONVENTIONS_FILE) ?? buildConventionsMemory(project),
+            rules: config?.rules ?? [],
+            contracts: config?.contracts ?? [],
+            agent: loadGuardAgentConfig(root),
+        });
+    });
+    server.registerResource('codapult_guard_architecture', 'codapult://guard/architecture', {
+        title: 'Guard Architecture Map',
+        description: 'Observed architecture and conventions.',
+        mimeType: 'application/json',
+    }, () => {
+        const root = findGuardRoot();
+        const project = discoverProject(root);
+        return jsonResource('codapult://guard/architecture', {
+            version: 1,
+            root,
+            architecture: loadGuardArtifact(root, GUARD_ARCHITECTURE_FILE) ?? buildArchitectureMemory(project),
+            conventions: loadGuardArtifact(root, GUARD_CONVENTIONS_FILE) ?? buildConventionsMemory(project),
+        });
+    });
+    server.registerResource('codapult_guard_proposals', 'codapult://guard/proposals', {
+        title: 'Architecture Guard Proposals',
+        description: 'Evidence-backed rules and contracts awaiting review.',
+        mimeType: 'application/json',
+    }, () => {
+        const root = findGuardRoot();
+        return jsonResource('codapult://guard/proposals', loadGuardProposals(root) ?? { version: 1, rules: [], contracts: [], questions: [] });
+    });
+}

package/dist/mcp/server.d.ts

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

package/dist/mcp/server.js

@@ -0,0 +1,17 @@
+import { createRequire } from 'node:module';
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { registerGuardTools } from './tools/guard.js';
+import { registerGuardPrompts } from './prompts.js';
+import { registerGuardResources } from './resources.js';
+const require = createRequire(import.meta.url);
+const packageJson = require('../../package.json');
+const server = new McpServer({
+    name: 'codapult-guard',
+    version: packageJson.version,
+});
+registerGuardTools(server);
+registerGuardPrompts(server);
+registerGuardResources(server);
+const transport = new StdioServerTransport();
+await server.connect(transport);

package/dist/mcp/tools/guard.d.ts

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

package/dist/mcp/tools/guard.js

@@ -0,0 +1,375 @@
+import { buildArchitectureMemory, buildConventionsMemory, buildGeneratedGuardConfig, buildGuardProposals, buildGuardReviewPacket, discoverProject, discoverProjectWithMetrics, findGuardRoot, GUARD_ARCHITECTURE_FILE, GUARD_CONVENTIONS_FILE, loadBaseline, loadGuardArtifact, loadGuardConfig, loadGuardAgentConfig, loadGuardProposals, getGuardProposalFreshness, loadProjectModel, writeGuardProposals, initializeGuard, GuardAlreadyInitializedError, recordGuardProposalDecision, writeGuardConfig, scanGuard, validateGuardContracts, classifyGuardOutcome, } from '../../core/guard.js';
+import { z } from 'zod';
+import { runGuardVerification } from '../../core/verification/verify.js';
+const rootSchema = z.string().trim().min(1).optional().describe('Project path or workspace root.');
+function getGuardRoot(root) {
+    return root ? findGuardRoot(root) : findGuardRoot();
+}
+function jsonToolResult(value, isError = false) {
+    return {
+        content: [{ type: 'text', text: JSON.stringify(value, null, 2) }],
+        ...(isError ? { isError: true } : {}),
+    };
+}
+export function registerGuardTools(server) {
+    server.registerTool('codapult_guard_context', {
+        title: 'Guard Context',
+        description: 'Read the discovered project model, architecture insights, and local rules used by Codapult Guard. Works before init by discovering the project on demand.',
+        inputSchema: {
+            root: rootSchema,
+            refresh: z
+                .boolean()
+                .default(true)
+                .describe('Rediscover the working tree instead of reading the persisted snapshot.'),
+        },
+    }, ({ root: requestedRoot, refresh }) => {
+        const root = getGuardRoot(requestedRoot);
+        const config = loadGuardConfig(root);
+        const agentConfig = loadGuardAgentConfig(root);
+        const discovery = refresh
+            ? discoverProjectWithMetrics(root, { persistCache: true })
+            : { model: loadProjectModel(root) ?? discoverProject(root), metrics: undefined };
+        const project = discovery.model;
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: JSON.stringify({
+                        version: 1,
+                        status: 'ok',
+                        outcome: classifyGuardOutcome({ configured: config !== undefined }),
+                        configured: config !== undefined,
+                        tools: agentConfig.tools,
+                        tooling: agentConfig.tooling,
+                        completionGate: agentConfig.completionGate,
+                        rules: config?.rules ?? [],
+                        contracts: config?.contracts ?? [],
+                        architecture: refresh
+                            ? buildArchitectureMemory(project)
+                            : (loadGuardArtifact(root, GUARD_ARCHITECTURE_FILE) ??
+                                buildArchitectureMemory(project)),
+                        conventions: refresh
+                            ? buildConventionsMemory(project)
+                            : (loadGuardArtifact(root, GUARD_CONVENTIONS_FILE) ??
+                                buildConventionsMemory(project)),
+                        project,
+                        discovery: discovery.metrics,
+                    }, null, 2),
+                },
+            ],
+        };
+    });
+    server.registerTool('codapult_guard_propose', {
+        title: 'Guard Proposals',
+        description: 'Generate evidence-based rule and contract proposals for an AI agent. Proposals are never activated automatically.',
+        inputSchema: {
+            root: rootSchema,
+            persist: z.boolean().default(false).describe('Persist proposals.json in the project.'),
+            confirm: z.boolean().default(false).describe('Required when persist is true.'),
+        },
+    }, ({ root: requestedRoot, persist, confirm }) => {
+        const root = getGuardRoot(requestedRoot);
+        if (persist && !confirm)
+            return jsonToolResult({ status: 'needs-confirmation', persist: true });
+        const project = discoverProject(root);
+        const config = loadGuardConfig(root) ?? buildGeneratedGuardConfig(project);
+        const proposals = buildGuardProposals(project, config);
+        const previous = loadGuardProposals(root);
+        if (persist) {
+            writeGuardProposals(root, {
+                ...proposals,
+                ...(previous?.decisions ? { decisions: previous.decisions } : {}),
+            });
+        }
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: JSON.stringify({
+                        status: 'ok',
+                        ...proposals,
+                        freshness: getGuardProposalFreshness(project, proposals),
+                        previousFreshness: getGuardProposalFreshness(project, previous),
+                        persisted: persist,
+                        instructions: 'Review evidence and questions with the user or host AI before activating any proposal.',
+                    }, null, 2),
+                },
+            ],
+        };
+    });
+    server.registerTool('codapult_guard_init', {
+        title: 'Initialize Guard',
+        description: 'Create Guard artifacts after explicit confirmation; existing baselines are protected by default.',
+        inputSchema: {
+            root: rootSchema,
+            confirm: z.boolean().default(false).describe('Required before writing Guard artifacts.'),
+            force: z
+                .boolean()
+                .default(false)
+                .describe('Replace existing Guard state; requires confirm.'),
+        },
+    }, ({ root: requestedRoot, confirm, force }) => {
+        const root = getGuardRoot(requestedRoot);
+        if (!confirm)
+            return jsonToolResult({ status: 'needs-confirmation', root, force });
+        try {
+            const result = initializeGuard(root, { force });
+            return jsonToolResult({ status: 'ok', root, report: result.report });
+        }
+        catch (error) {
+            const status = error instanceof GuardAlreadyInitializedError ? 'already-initialized' : 'fail';
+            return jsonToolResult({ status, root, message: error instanceof Error ? error.message : String(error) }, true);
+        }
+    });
+    server.registerTool('codapult_guard_proposal_decide', {
+        title: 'Decide Guard Proposals',
+        description: 'Approve or reject current evidence-backed proposals; stale proposals cannot be activated.',
+        inputSchema: {
+            root: rootSchema,
+            ids: z.array(z.string().trim().min(1)).min(1),
+            decision: z.enum(['approved', 'rejected']),
+            confirm: z.boolean().default(false).describe('Required before changing Guard state.'),
+        },
+    }, ({ root: requestedRoot, ids, decision, confirm }) => {
+        const root = getGuardRoot(requestedRoot);
+        const proposals = loadGuardProposals(root);
+        if (!proposals)
+            return jsonToolResult({ status: 'not-configured', message: 'No proposals found.' }, true);
+        const project = discoverProject(root);
+        if (getGuardProposalFreshness(project, proposals) === 'stale') {
+            return jsonToolResult({ status: 'stale', message: 'Regenerate proposals before deciding on them.' }, true);
+        }
+        const selected = [...proposals.rules, ...proposals.contracts].filter((item) => ids.includes(item.id));
+        const missing = ids.filter((id) => !selected.some((item) => item.id === id));
+        if (missing.length > 0)
+            return jsonToolResult({ status: 'invalid', missing }, true);
+        if (!confirm)
+            return jsonToolResult({ status: 'needs-confirmation', decision, ids });
+        if (decision === 'approved') {
+            const config = loadGuardConfig(root) ?? { version: 1, rules: [], contracts: [] };
+            const nextRules = [...config.rules];
+            const nextContracts = [...(config.contracts ?? [])];
+            for (const item of selected) {
+                if ('statement' in item) {
+                    const index = nextContracts.findIndex((contract) => contract.id === item.id);
+                    const active = { ...item, status: 'active' };
+                    if (index >= 0)
+                        nextContracts[index] = active;
+                    else
+                        nextContracts.push(active);
+                }
+                else {
+                    const index = nextRules.findIndex((rule) => rule.id === item.id);
+                    const active = { ...item, status: 'active' };
+                    if (index >= 0)
+                        nextRules[index] = active;
+                    else
+                        nextRules.push(active);
+                }
+            }
+            writeGuardConfig(root, { version: 1, rules: nextRules, contracts: nextContracts });
+        }
+        recordGuardProposalDecision(root, selected.map((item) => ({
+            id: item.id,
+            type: 'statement' in item ? 'contract' : 'rule',
+            decision,
+        })));
+        return jsonToolResult({ status: 'ok', root, decision, ids });
+    });
+    server.registerTool('codapult_guard_verify', {
+        title: 'Guard Verify',
+        description: 'Run project checks, production build, and architecture regression checks as one verification gate.',
+        inputSchema: {
+            root: rootSchema,
+            checks: z
+                .array(z.enum(['lint', 'typecheck', 'test', 'build']))
+                .optional()
+                .describe('Checks to run; defaults to lint, typecheck, test, and build.'),
+            changed_only: z.boolean().optional(),
+            requirement: z.string().trim().min(1).max(20_000).optional(),
+            tools: z
+                .enum(['auto', 'on', 'off'])
+                .optional()
+                .describe('External tools mode; defaults to agent.json.'),
+            strict: z.boolean().optional(),
+            project_checks: z
+                .boolean()
+                .optional()
+                .describe('Override completionGate.projectChecks for this invocation.'),
+            iteration: z.number().int().positive().default(1),
+        },
+    }, ({ root: requestedRoot, checks, changed_only, requirement, tools, strict, project_checks, iteration, }) => {
+        const root = getGuardRoot(requestedRoot);
+        const result = runGuardVerification(root, {
+            checks,
+            changedOnly: changed_only,
+            requirement,
+            tools,
+            strict,
+            projectChecks: project_checks,
+        });
+        const completionGate = loadGuardAgentConfig(root).completionGate;
+        return jsonToolResult({
+            ...result,
+            completionGate: {
+                ...completionGate,
+                iteration,
+                canRetry: result.status === 'fail' && iteration < completionGate.maxIterations,
+            },
+        }, result.status === 'fail');
+    });
+    server.registerTool('codapult_guard_audit', {
+        title: 'Guard Audit',
+        description: 'Run a full Guard audit, ignoring baseline suppression and validating contracts.',
+        inputSchema: { root: rootSchema },
+    }, ({ root: requestedRoot }) => {
+        const root = getGuardRoot(requestedRoot);
+        const config = loadGuardConfig(root);
+        if (!config) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify({ configured: false, outcome: 'not-configured' }, null, 2),
+                    },
+                ],
+                isError: true,
+            };
+        }
+        const report = scanGuard(root, config, { includeArchitectureInsights: true });
+        const contractIssues = validateGuardContracts(root, config.contracts ?? []);
+        const errors = report.findings.filter((finding) => finding.severity === 'error').length;
+        const warnings = report.findings.filter((finding) => finding.severity === 'warning').length;
+        const status = errors > 0 || contractIssues.length > 0 ? 'fail' : warnings > 0 ? 'warning' : 'ok';
+        return jsonToolResult({
+            status,
+            outcome: classifyGuardOutcome({
+                errors: errors + contractIssues.length,
+                warnings,
+            }),
+            errors,
+            warnings,
+            contractIssues,
+            report,
+        }, status === 'fail');
+    });
+    server.registerTool('codapult_guard_review', {
+        title: 'Prepare Guard Review',
+        description: 'Prepare a bounded semantic-review packet containing the current diff, project model, contracts, and deterministic findings for an AI reviewer.',
+        inputSchema: {
+            root: rootSchema,
+            changed_only: z.boolean().default(true),
+            max_diff_chars: z.number().int().positive().max(500_000).default(120_000),
+            requirement: z.string().trim().min(1).max(20_000).optional(),
+            base: z
+                .string()
+                .trim()
+                .min(1)
+                .optional()
+                .describe('Git base ref for PR review, e.g. origin/main.'),
+        },
+    }, ({ root: requestedRoot, changed_only, max_diff_chars, requirement, base }) => {
+        const root = getGuardRoot(requestedRoot);
+        const config = loadGuardConfig(root);
+        if (!config) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify({ configured: false, outcome: 'not-configured' }, null, 2),
+                    },
+                ],
+                isError: true,
+            };
+        }
+        const packet = buildGuardReviewPacket(root, config, changed_only ? loadBaseline(root) : new Set(), max_diff_chars, changed_only, requirement, base);
+        return jsonToolResult({ ...packet, status: packet.diffError ? 'fail' : 'needs-review' }, Boolean(packet.diffError));
+    });
+    server.registerTool('codapult_guard_check', {
+        title: 'Guard Check',
+        description: 'Check project architecture rules and return structured new violations.',
+        inputSchema: { root: rootSchema, changed_only: z.boolean().optional() },
+    }, ({ root: requestedRoot, changed_only }) => {
+        const root = getGuardRoot(requestedRoot);
+        const config = loadGuardConfig(root);
+        if (!config) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify({ configured: false, outcome: 'not-configured' }, null, 2),
+                    },
+                ],
+                isError: true,
+            };
+        }
+        const report = scanGuard(root, config, {
+            changedOnly: changed_only,
+            baseline: loadBaseline(root),
+            includeArchitectureInsights: true,
+        });
+        const contractIssues = validateGuardContracts(root, config.contracts ?? []);
+        const errors = report.findings.filter((finding) => finding.severity === 'error').length;
+        return jsonToolResult({
+            status: errors > 0 || contractIssues.length > 0 ? 'fail' : 'ok',
+            outcome: classifyGuardOutcome({
+                errors: errors + contractIssues.length,
+                warnings: report.findings.filter((finding) => finding.severity === 'warning').length,
+            }),
+            contractIssues,
+            ...report,
+        }, errors > 0 || contractIssues.length > 0);
+    });
+    server.registerTool('codapult_guard_impact', {
+        title: 'Guard Impact Analysis',
+        description: 'Explain the project impact of one or more changed files using the discovered dependency graph, routes, capabilities, and contracts.',
+        inputSchema: {
+            root: rootSchema,
+            files: z.array(z.string().trim().min(1)).min(1),
+        },
+    }, ({ root: requestedRoot, files }) => {
+        const root = getGuardRoot(requestedRoot);
+        const model = discoverProject(root);
+        const changed = new Set(files);
+        const paths = model.insights.impactPaths.filter((impact) => impact.files.some((file) => changed.has(file)) || changed.has(impact.entrypoint));
+        const modules = model.modules.filter((module) => changed.has(module.path) || module.resolvedImports.some((file) => changed.has(file)));
+        const capabilities = Object.entries(model.capabilities)
+            .filter(([, signal]) => signal.files.some((file) => changed.has(file)))
+            .map(([id]) => id);
+        const contracts = (loadGuardConfig(root)?.contracts ?? []).filter((contract) => [...(contract.scope ?? []), ...(contract.entrypoints ?? [])].some((scope) => [...changed].some((file) => file === scope || file.startsWith(`${scope}/`))));
+        return jsonToolResult({
+            status: 'ok',
+            files,
+            affectedModules: modules.map((module) => module.path),
+            impactPaths: paths,
+            capabilities,
+            relevantContracts: contracts,
+        });
+    });
+    server.registerTool('codapult_guard_explain', {
+        title: 'Explain Guard Policy',
+        description: 'Explain a Guard rule or contract with its evidence and applicable scope.',
+        inputSchema: {
+            root: rootSchema,
+            id: z.string().trim().min(1),
+        },
+    }, ({ root: requestedRoot, id }) => {
+        const root = getGuardRoot(requestedRoot);
+        const config = loadGuardConfig(root);
+        const item = [...(config?.rules ?? []), ...(config?.contracts ?? [])].find((candidate) => candidate.id === id);
+        if (!item)
+            return jsonToolResult({ status: 'not-found', id }, true);
+        return jsonToolResult({
+            status: 'ok',
+            id,
+            policy: item,
+            evidence: 'evidence' in item ? (item.evidence ?? []) : [],
+            guidance: 'guidance' in item ? (item.guidance ?? []) : [],
+            nextSteps: [
+                'Inspect the referenced project modules and current diff.',
+                'Use an existing project boundary that satisfies the policy.',
+                'If the policy is no longer correct, update it through a reviewed project change.',
+            ],
+        });
+    });
+}

package/package.json

@@ -0,0 +1,117 @@
+{
+  "name": "@codapult/guard",
+  "version": "0.1.0",
+  "description": "Local-first architecture guardrails for JavaScript and TypeScript projects, with first-class support for Next.js SaaS and AI-assisted development",
+  "license": "MIT",
+  "packageManager": "pnpm@11.22.0+sha512.1ff870c4c6133dfd88fb2afc46dd13d47f09c9794b438c6fdb47ca98caf3bc16381ee0be93a091b8e3824cf01f889f46d7d9e20910fb0be1ab0fb5baa80dd621",
+  "engines": {
+    "node": ">=20.19.0"
+  },
+  "type": "module",
+  "bin": {
+    "codapult-guard": "./dist/cli/index.js"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./cli": {
+      "types": "./dist/cli/index.d.ts",
+      "import": "./dist/cli/index.js"
+    },
+    "./mcp": {
+      "types": "./dist/mcp/tools/guard.d.ts",
+      "import": "./dist/mcp/tools/guard.js"
+    },
+    "./commands/guard": {
+      "types": "./dist/cli/commands/guard.d.ts",
+      "import": "./dist/cli/commands/guard.js"
+    },
+    "./mcp/prompts": {
+      "types": "./dist/mcp/prompts.d.ts",
+      "import": "./dist/mcp/prompts.js"
+    },
+    "./mcp/resources": {
+      "types": "./dist/mcp/resources.d.ts",
+      "import": "./dist/mcp/resources.js"
+    },
+    "./project-checks": {
+      "types": "./dist/adapters/project-checks.d.ts",
+      "import": "./dist/adapters/project-checks.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "clean": "node scripts/clean-dist.mjs",
+    "build": "pnpm clean && tsc -p tsconfig.build.json",
+    "dev": "tsc --watch",
+    "lint": "eslint .",
+    "lint:fix": "eslint --fix .",
+    "format": "prettier --write .",
+    "format:check": "prettier --check .",
+    "release:check": "pnpm lint && pnpm format:check && pnpm typecheck && pnpm test && pnpm build && npm pack --dry-run",
+    "test": "vitest run",
+    "test:coverage": "vitest run --coverage",
+    "test:guard:coverage": "vitest run src/core src/adapters/project-checks.test.ts --coverage --coverage.include='src/core/**/*.ts' --coverage.include='src/adapters/project-checks.ts'",
+    "test:guard:fixtures": "pnpm build && node scripts/guard-fixture-smoke.mjs",
+    "test:guard:fixtures:regression": "pnpm build && node scripts/guard-fixture-regression.mjs",
+    "test:guard:fixtures:native": "pnpm build && node scripts/guard-fixture-native.mjs",
+    "test:guard:pr": "pnpm build && node scripts/guard-pr-review.mjs",
+    "test:guard:golden": "pnpm build && node scripts/guard-golden-demo.mjs",
+    "test:watch": "vitest",
+    "typecheck": "tsc --noEmit",
+    "prepublishOnly": "tsc -p tsconfig.build.json",
+    "release": "release-it"
+  },
+  "keywords": [
+    "codapult",
+    "architecture",
+    "guardrails",
+    "ai-agents",
+    "cli",
+    "nextjs",
+    "javascript",
+    "typescript",
+    "react",
+    "mcp",
+    "saas"
+  ],
+  "homepage": "https://github.com/codapult/codapult-guard",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/codapult/codapult-guard.git"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.30.0",
+    "commander": "^15.0.0",
+    "picocolors": "^1.1.1",
+    "semver": "^7.8.5",
+    "ts-morph": "^28.0.0",
+    "typescript": "npm:@typescript/typescript6@^6.0.2",
+    "zod": "^4.4.3"
+  },
+  "devDependencies": {
+    "@js-toolkit/config-utils": "^1.0.1",
+    "@js-toolkit/eslint-config": "^1.1.4",
+    "@js-toolkit/prettier-config": "^1.0.1",
+    "@js-toolkit/tsconfig": "^1.0.1",
+    "@release-it/conventional-changelog": "^12.0.0",
+    "@types/node": "^26.2.0",
+    "@typescript/native": "npm:typescript@^7.0.2",
+    "@vitest/coverage-v8": "^4.1.11",
+    "eslint": "^9.39.4",
+    "eslint-config-prettier": "^10.1.8",
+    "eslint-plugin-prettier": "^5.5.6",
+    "prettier": "^3.9.6",
+    "release-it": "^21.0.2",
+    "typescript-eslint": "^8.67.0",
+    "vitest": "^4.1.11"
+  }
+}