guardrail-core 1.0.0

package/dist/verified-autofix/__tests__/repo-fingerprint.test.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Repo Fingerprint Tests
+ *
+ * Tests for project detection and configuration:
+ * - Package manager detection
+ * - Build tool detection
+ * - Framework detection
+ * - Test runner detection
+ */
+export {};
+//# sourceMappingURL=repo-fingerprint.test.d.ts.map

package/dist/verified-autofix/__tests__/repo-fingerprint.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"repo-fingerprint.test.d.ts","sourceRoot":"","sources":["../../../src/verified-autofix/__tests__/repo-fingerprint.test.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG"}

package/dist/verified-autofix/__tests__/repo-fingerprint.test.js

@@ -0,0 +1,236 @@
+"use strict";
+/**
+ * Repo Fingerprint Tests
+ *
+ * Tests for project detection and configuration:
+ * - Package manager detection
+ * - Build tool detection
+ * - Framework detection
+ * - Test runner detection
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+const repo_fingerprint_1 = require("../repo-fingerprint");
+describe('fingerprintRepo', () => {
+    let tempDir;
+    beforeEach(async () => {
+        tempDir = await fs.promises.mkdtemp(path.join(os.tmpdir(), 'fingerprint-test-'));
+    });
+    afterEach(async () => {
+        await fs.promises.rm(tempDir, { recursive: true, force: true });
+    });
+    it('detects pnpm from lock file', async () => {
+        await fs.promises.writeFile(path.join(tempDir, 'pnpm-lock.yaml'), '');
+        await fs.promises.writeFile(path.join(tempDir, 'package.json'), JSON.stringify({
+            name: 'test',
+            dependencies: {},
+        }));
+        const { fingerprint } = (0, repo_fingerprint_1.fingerprintRepo)(tempDir);
+        expect(fingerprint.packageManager).toBe('pnpm');
+    });
+    it('detects yarn from lock file', async () => {
+        await fs.promises.writeFile(path.join(tempDir, 'yarn.lock'), '');
+        await fs.promises.writeFile(path.join(tempDir, 'package.json'), JSON.stringify({
+            name: 'test',
+        }));
+        const { fingerprint } = (0, repo_fingerprint_1.fingerprintRepo)(tempDir);
+        expect(fingerprint.packageManager).toBe('yarn');
+    });
+    it('detects npm from lock file', async () => {
+        await fs.promises.writeFile(path.join(tempDir, 'package-lock.json'), '{}');
+        await fs.promises.writeFile(path.join(tempDir, 'package.json'), JSON.stringify({
+            name: 'test',
+        }));
+        const { fingerprint } = (0, repo_fingerprint_1.fingerprintRepo)(tempDir);
+        expect(fingerprint.packageManager).toBe('npm');
+    });
+    it('detects Next.js framework', async () => {
+        await fs.promises.writeFile(path.join(tempDir, 'package.json'), JSON.stringify({
+            name: 'test',
+            dependencies: { next: '^14.0.0', react: '^18.0.0' },
+        }));
+        const { fingerprint } = (0, repo_fingerprint_1.fingerprintRepo)(tempDir);
+        expect(fingerprint.framework).toBe('next');
+    });
+    it('detects Vite framework', async () => {
+        await fs.promises.writeFile(path.join(tempDir, 'package.json'), JSON.stringify({
+            name: 'test',
+            devDependencies: { vite: '^5.0.0' },
+        }));
+        const { fingerprint } = (0, repo_fingerprint_1.fingerprintRepo)(tempDir);
+        expect(fingerprint.framework).toBe('vite');
+    });
+    it('detects Jest test runner', async () => {
+        await fs.promises.writeFile(path.join(tempDir, 'package.json'), JSON.stringify({
+            name: 'test',
+            devDependencies: { jest: '^29.0.0' },
+        }));
+        const { fingerprint } = (0, repo_fingerprint_1.fingerprintRepo)(tempDir);
+        expect(fingerprint.testRunner).toBe('jest');
+    });
+    it('detects Vitest test runner', async () => {
+        await fs.promises.writeFile(path.join(tempDir, 'package.json'), JSON.stringify({
+            name: 'test',
+            devDependencies: { vitest: '^1.0.0' },
+        }));
+        const { fingerprint } = (0, repo_fingerprint_1.fingerprintRepo)(tempDir);
+        expect(fingerprint.testRunner).toBe('vitest');
+    });
+    it('detects TypeScript', async () => {
+        await fs.promises.writeFile(path.join(tempDir, 'tsconfig.json'), '{}');
+        await fs.promises.writeFile(path.join(tempDir, 'package.json'), JSON.stringify({
+            name: 'test',
+        }));
+        const { fingerprint } = (0, repo_fingerprint_1.fingerprintRepo)(tempDir);
+        expect(fingerprint.hasTypeScript).toBe(true);
+    });
+    it('detects Turbo build tool', async () => {
+        await fs.promises.writeFile(path.join(tempDir, 'turbo.json'), '{}');
+        await fs.promises.writeFile(path.join(tempDir, 'package.json'), JSON.stringify({
+            name: 'test',
+        }));
+        const { fingerprint } = (0, repo_fingerprint_1.fingerprintRepo)(tempDir);
+        expect(fingerprint.buildTool).toBe('turbo');
+    });
+    it('detects monorepo from workspaces', async () => {
+        await fs.promises.writeFile(path.join(tempDir, 'package.json'), JSON.stringify({
+            name: 'monorepo',
+            workspaces: ['packages/*'],
+        }));
+        const { fingerprint } = (0, repo_fingerprint_1.fingerprintRepo)(tempDir);
+        expect(fingerprint.isMonorepo).toBe(true);
+        expect(fingerprint.workspaces).toContain('packages/*');
+    });
+    it('detects build script', async () => {
+        await fs.promises.writeFile(path.join(tempDir, 'package.json'), JSON.stringify({
+            name: 'test',
+            scripts: { build: 'tsc' },
+        }));
+        const { fingerprint } = (0, repo_fingerprint_1.fingerprintRepo)(tempDir);
+        expect(fingerprint.hasBuildScript).toBe(true);
+    });
+    it('handles missing package.json gracefully', () => {
+        const { fingerprint, confidence, detectionNotes } = (0, repo_fingerprint_1.fingerprintRepo)(tempDir);
+        expect(fingerprint.packageManager).toBe('unknown');
+        expect(confidence).toBeLessThan(100);
+        expect(detectionNotes).toContain('No package.json found');
+    });
+});
+describe('command helpers', () => {
+    it('returns correct install command for pnpm', () => {
+        expect((0, repo_fingerprint_1.getInstallCommand)('pnpm')).toBe('pnpm install --frozen-lockfile');
+    });
+    it('returns correct install command for yarn', () => {
+        expect((0, repo_fingerprint_1.getInstallCommand)('yarn')).toBe('yarn install --frozen-lockfile');
+    });
+    it('returns correct install command for npm', () => {
+        expect((0, repo_fingerprint_1.getInstallCommand)('npm')).toBe('npm ci');
+    });
+    it('returns turbo build command when turbo detected', () => {
+        const fingerprint = {
+            buildTool: 'turbo',
+            hasBuildScript: true,
+            hasTypeScript: true,
+            packageManager: 'pnpm',
+            framework: 'next',
+            testRunner: 'jest',
+            hasESLint: true,
+            hasPrettier: true,
+            hasTestScript: true,
+            isMonorepo: true,
+            workspaces: ['packages/*'],
+            dependencies: {},
+            devDependencies: {},
+        };
+        expect((0, repo_fingerprint_1.getBuildCommand)(fingerprint)).toBe('npx turbo run build');
+    });
+    it('returns vitest command for vitest runner', () => {
+        const fingerprint = {
+            testRunner: 'vitest',
+            hasTestScript: true,
+            buildTool: 'none',
+            hasBuildScript: false,
+            hasTypeScript: false,
+            packageManager: 'npm',
+            framework: 'none',
+            hasESLint: false,
+            hasPrettier: false,
+            isMonorepo: false,
+            workspaces: [],
+            dependencies: {},
+            devDependencies: {},
+        };
+        expect((0, repo_fingerprint_1.getTestCommand)(fingerprint)).toBe('npx vitest run');
+    });
+    it('returns typecheck command when TypeScript present', () => {
+        const fingerprint = {
+            hasTypeScript: true,
+            testRunner: 'none',
+            hasTestScript: false,
+            buildTool: 'none',
+            hasBuildScript: false,
+            packageManager: 'npm',
+            framework: 'none',
+            hasESLint: false,
+            hasPrettier: false,
+            isMonorepo: false,
+            workspaces: [],
+            dependencies: {},
+            devDependencies: {},
+        };
+        expect((0, repo_fingerprint_1.getTypecheckCommand)(fingerprint)).toBe('npx tsc --noEmit');
+    });
+    it('returns null typecheck command when no TypeScript', () => {
+        const fingerprint = {
+            hasTypeScript: false,
+            testRunner: 'none',
+            hasTestScript: false,
+            buildTool: 'none',
+            hasBuildScript: false,
+            packageManager: 'npm',
+            framework: 'none',
+            hasESLint: false,
+            hasPrettier: false,
+            isMonorepo: false,
+            workspaces: [],
+            dependencies: {},
+            devDependencies: {},
+        };
+        expect((0, repo_fingerprint_1.getTypecheckCommand)(fingerprint)).toBeNull();
+    });
+});

package/dist/verified-autofix/__tests__/workspace.test.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Workspace Tests - Temp Workspace Manager
+ *
+ * Tests for isolated workspace verification:
+ * - Workspace creation (copy and worktree)
+ * - Diff application via git apply
+ * - Verification command execution
+ * - Top 3 failure context extraction
+ */
+export {};
+//# sourceMappingURL=workspace.test.d.ts.map

package/dist/verified-autofix/__tests__/workspace.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"workspace.test.d.ts","sourceRoot":"","sources":["../../../src/verified-autofix/__tests__/workspace.test.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG"}

package/dist/verified-autofix/__tests__/workspace.test.js

@@ -0,0 +1,314 @@
+"use strict";
+/**
+ * Workspace Tests - Temp Workspace Manager
+ *
+ * Tests for isolated workspace verification:
+ * - Workspace creation (copy and worktree)
+ * - Diff application via git apply
+ * - Verification command execution
+ * - Top 3 failure context extraction
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+const child_process_1 = require("child_process");
+const workspace_1 = require("../workspace");
+describe('TempWorkspace', () => {
+    let tempDir;
+    let workspace;
+    beforeEach(async () => {
+        tempDir = await fs.promises.mkdtemp(path.join(os.tmpdir(), 'workspace-test-'));
+        workspace = new workspace_1.TempWorkspace();
+        // Create minimal project structure
+        await fs.promises.writeFile(path.join(tempDir, 'package.json'), JSON.stringify({
+            name: 'test-project',
+            version: '1.0.0',
+            scripts: {
+                build: 'echo "build complete"',
+                test: 'echo "tests passed"',
+            },
+        }));
+        // Create a source file
+        await fs.promises.mkdir(path.join(tempDir, 'src'), { recursive: true });
+        await fs.promises.writeFile(path.join(tempDir, 'src', 'index.ts'), 'export const version = "1.0.0";\n');
+    });
+    afterEach(async () => {
+        await workspace.cleanupAll();
+        await fs.promises.rm(tempDir, { recursive: true, force: true });
+    });
+    describe('create', () => {
+        it('creates workspace via copy when not a git repo', async () => {
+            const info = await workspace.create({
+                projectPath: tempDir,
+                useWorktree: true, // Will fall back to copy since no .git
+            });
+            expect(info.type).toBe('copy');
+            expect(fs.existsSync(info.path)).toBe(true);
+            expect(fs.existsSync(path.join(info.path, 'package.json'))).toBe(true);
+            expect(fs.existsSync(path.join(info.path, 'src', 'index.ts'))).toBe(true);
+        });
+        it('excludes node_modules from copy', async () => {
+            // Create fake node_modules
+            await fs.promises.mkdir(path.join(tempDir, 'node_modules', 'lodash'), { recursive: true });
+            await fs.promises.writeFile(path.join(tempDir, 'node_modules', 'lodash', 'index.js'), 'module.exports = {};');
+            const info = await workspace.create({
+                projectPath: tempDir,
+            });
+            expect(fs.existsSync(path.join(info.path, 'node_modules'))).toBe(false);
+        });
+        it('excludes .git from copy', async () => {
+            // Create fake .git
+            await fs.promises.mkdir(path.join(tempDir, '.git'), { recursive: true });
+            await fs.promises.writeFile(path.join(tempDir, '.git', 'config'), '');
+            const info = await workspace.create({
+                projectPath: tempDir,
+                useWorktree: false, // Force copy mode
+            });
+            expect(fs.existsSync(path.join(info.path, '.git'))).toBe(false);
+        });
+    });
+    describe('applyDiff', () => {
+        it('applies simple hunk to file', async () => {
+            const info = await workspace.create({ projectPath: tempDir });
+            const hunks = [{
+                    file: 'src/index.ts',
+                    oldStart: 1,
+                    oldLines: 1,
+                    newStart: 1,
+                    newLines: 2,
+                    content: `@@ -1,1 +1,2 @@
+ export const version = "1.0.0";
++export const name = "test";`,
+                }];
+            const diff = `--- a/src/index.ts
++++ b/src/index.ts
+@@ -1,1 +1,2 @@
+ export const version = "1.0.0";
++export const name = "test";`;
+            const result = await workspace.applyDiff(info.path, diff, hunks);
+            expect(result.success).toBe(true);
+            expect(result.applied).toBe(1);
+            expect(result.errors).toHaveLength(0);
+            // Verify file was modified
+            const content = await fs.promises.readFile(path.join(info.path, 'src', 'index.ts'), 'utf8');
+            expect(content).toContain('export const name = "test"');
+        });
+        it('creates new file from diff', async () => {
+            const info = await workspace.create({ projectPath: tempDir });
+            const hunks = [{
+                    file: 'src/utils.ts',
+                    oldStart: 0,
+                    oldLines: 0,
+                    newStart: 1,
+                    newLines: 1,
+                    content: `@@ -0,0 +1,1 @@
++export const add = (a: number, b: number) => a + b;`,
+                }];
+            const diff = `--- /dev/null
++++ b/src/utils.ts
+@@ -0,0 +1,1 @@
++export const add = (a: number, b: number) => a + b;`;
+            const result = await workspace.applyDiff(info.path, diff, hunks);
+            expect(result.applied).toBeGreaterThan(0);
+            expect(fs.existsSync(path.join(info.path, 'src', 'utils.ts'))).toBe(true);
+        });
+    });
+    describe('verify', () => {
+        it('runs verification commands based on fingerprint', async () => {
+            const info = await workspace.create({ projectPath: tempDir });
+            const fingerprint = {
+                packageManager: 'npm',
+                buildTool: 'none',
+                framework: 'none',
+                testRunner: 'none',
+                hasTypeScript: false,
+                hasESLint: false,
+                hasPrettier: false,
+                hasBuildScript: true,
+                hasTestScript: true,
+                isMonorepo: false,
+                workspaces: [],
+                dependencies: {},
+                devDependencies: {},
+            };
+            const result = await workspace.verify(info.path, fingerprint, {
+                skipTests: true,
+            });
+            // Build should pass (echo command)
+            expect(result.passed).toBe(true);
+            expect(result.checks.length).toBeGreaterThan(0);
+        });
+        it('extracts top 3 failure context on error', async () => {
+            const info = await workspace.create({ projectPath: tempDir });
+            // Create a failing build script
+            await fs.promises.writeFile(path.join(info.path, 'package.json'), JSON.stringify({
+                name: 'test',
+                scripts: {
+                    build: 'echo "error TS2322: Type mismatch" && echo "error TS2345: Wrong arg" && echo "error TS2339: Missing prop" && exit 1',
+                },
+            }));
+            const fingerprint = {
+                packageManager: 'npm',
+                buildTool: 'none',
+                framework: 'none',
+                testRunner: 'none',
+                hasTypeScript: false,
+                hasESLint: false,
+                hasPrettier: false,
+                hasBuildScript: true,
+                hasTestScript: false,
+                isMonorepo: false,
+                workspaces: [],
+                dependencies: {},
+                devDependencies: {},
+            };
+            const result = await workspace.verify(info.path, fingerprint, {
+                skipTests: true,
+            });
+            expect(result.passed).toBe(false);
+            expect(result.failureContext.length).toBeLessThanOrEqual(3);
+        });
+    });
+    describe('copyBack', () => {
+        it('copies modified files back to project', async () => {
+            const info = await workspace.create({ projectPath: tempDir });
+            // Modify file in workspace
+            await fs.promises.writeFile(path.join(info.path, 'src', 'index.ts'), 'export const version = "2.0.0";\n');
+            await workspace.copyBack(info.path, tempDir, ['src/index.ts']);
+            // Verify original project was updated
+            const content = await fs.promises.readFile(path.join(tempDir, 'src', 'index.ts'), 'utf8');
+            expect(content).toBe('export const version = "2.0.0";\n');
+        });
+        it('creates backup before overwriting', async () => {
+            const info = await workspace.create({ projectPath: tempDir });
+            // Modify file in workspace
+            await fs.promises.writeFile(path.join(info.path, 'src', 'index.ts'), 'export const version = "2.0.0";\n');
+            await workspace.copyBack(info.path, tempDir, ['src/index.ts']);
+            // Backup should exist
+            const backupPath = path.join(tempDir, 'src', 'index.ts.guardrail-backup');
+            expect(fs.existsSync(backupPath)).toBe(true);
+            const backupContent = await fs.promises.readFile(backupPath, 'utf8');
+            expect(backupContent).toBe('export const version = "1.0.0";\n');
+        });
+    });
+    describe('cleanup', () => {
+        it('removes workspace directory', async () => {
+            const info = await workspace.create({ projectPath: tempDir });
+            const workspacePath = info.path;
+            expect(fs.existsSync(workspacePath)).toBe(true);
+            await workspace.cleanup(info.id);
+            expect(fs.existsSync(workspacePath)).toBe(false);
+        });
+    });
+});
+describe('TempWorkspace with git repo', () => {
+    let tempDir;
+    let workspace;
+    let isGitAvailable;
+    beforeAll(() => {
+        // Check if git is available
+        try {
+            (0, child_process_1.execSync)('git --version', { stdio: 'pipe' });
+            isGitAvailable = true;
+        }
+        catch {
+            isGitAvailable = false;
+        }
+    });
+    beforeEach(async () => {
+        if (!isGitAvailable)
+            return;
+        tempDir = await fs.promises.mkdtemp(path.join(os.tmpdir(), 'workspace-git-test-'));
+        workspace = new workspace_1.TempWorkspace();
+        // Initialize git repo
+        (0, child_process_1.execSync)('git init', { cwd: tempDir, stdio: 'pipe' });
+        (0, child_process_1.execSync)('git config user.email "test@test.com"', { cwd: tempDir, stdio: 'pipe' });
+        (0, child_process_1.execSync)('git config user.name "Test"', { cwd: tempDir, stdio: 'pipe' });
+        // Create and commit a file
+        await fs.promises.writeFile(path.join(tempDir, 'file.ts'), 'const x = 1;\n');
+        (0, child_process_1.execSync)('git add .', { cwd: tempDir, stdio: 'pipe' });
+        (0, child_process_1.execSync)('git commit -m "initial"', { cwd: tempDir, stdio: 'pipe' });
+    });
+    afterEach(async () => {
+        if (!isGitAvailable)
+            return;
+        await workspace.cleanupAll();
+        await fs.promises.rm(tempDir, { recursive: true, force: true });
+    });
+    it('uses git worktree when available', async () => {
+        if (!isGitAvailable) {
+            console.log('Skipping git worktree test - git not available');
+            return;
+        }
+        const info = await workspace.create({
+            projectPath: tempDir,
+            useWorktree: true,
+        });
+        expect(info.type).toBe('worktree');
+        expect(fs.existsSync(path.join(info.path, 'file.ts'))).toBe(true);
+    });
+    it('applies diff with git apply', async () => {
+        if (!isGitAvailable) {
+            console.log('Skipping git apply test - git not available');
+            return;
+        }
+        const info = await workspace.create({
+            projectPath: tempDir,
+            useWorktree: true,
+        });
+        const diff = `--- a/file.ts
++++ b/file.ts
+@@ -1 +1,2 @@
+ const x = 1;
++const y = 2;
+`;
+        const hunks = [{
+                file: 'file.ts',
+                oldStart: 1,
+                oldLines: 1,
+                newStart: 1,
+                newLines: 2,
+                content: `@@ -1 +1,2 @@
+ const x = 1;
++const y = 2;`,
+            }];
+        const result = await workspace.applyDiff(info.path, diff, hunks);
+        expect(result.success).toBe(true);
+        const content = await fs.promises.readFile(path.join(info.path, 'file.ts'), 'utf8');
+        expect(content).toContain('const y = 2');
+    });
+});

package/dist/verified-autofix/format-validator.d.ts

@@ -0,0 +1,101 @@
+/**
+ * Format Validator - Strict Output Protocol Enforcement
+ *
+ * Validates AI agent output format:
+ * 1. JSON shape validation (guardrail-v1 format)
+ * 2. Unified diff validity checking
+ * 3. Markdown fence stripping (forgiving)
+ * 4. Path safety validation
+ * 5. Stub/placeholder detection
+ */
+export interface GuardrailV1Output {
+    format: 'guardrail-v1';
+    diff: string;
+    commands: string[];
+    tests: string[];
+    notes: string;
+}
+export interface ValidationResult {
+    valid: boolean;
+    errors: string[];
+    warnings: string[];
+    sanitized?: GuardrailV1Output;
+}
+export interface DiffValidationResult {
+    valid: boolean;
+    errors: string[];
+    hunks: ParsedHunk[];
+    filesAffected: string[];
+}
+export interface ParsedHunk {
+    file: string;
+    oldStart: number;
+    oldLines: number;
+    newStart: number;
+    newLines: number;
+    content: string;
+}
+/**
+ * Strip markdown code fences from raw agent output (forgiving mode)
+ */
+export declare function stripMarkdownFences(raw: string): string;
+/**
+ * Validate the guardrail-v1 JSON shape
+ */
+export declare function validateJsonShape(obj: unknown): ValidationResult;
+/**
+ * Parse and validate unified diff format
+ */
+export declare function validateUnifiedDiff(diff: string): DiffValidationResult;
+/**
+ * Validate that file paths are safe (no traversal, no system paths)
+ */
+export declare function validatePathSafety(paths: string[], projectRoot: string): {
+    safe: boolean;
+    issues: string[];
+};
+/**
+ * Validate that commands are safe to run
+ */
+export declare function validateCommandSafety(commands: string[]): {
+    safe: boolean;
+    issues: string[];
+};
+/**
+ * Detect placeholder/stub code in diff additions
+ */
+export declare function detectStubs(diff: string): {
+    hasStubs: boolean;
+    stubs: string[];
+};
+export interface FullValidationResult {
+    valid: boolean;
+    errors: string[];
+    warnings: string[];
+    output?: GuardrailV1Output;
+    diffValidation?: DiffValidationResult;
+    pathSafety?: {
+        safe: boolean;
+        issues: string[];
+    };
+    commandSafety?: {
+        safe: boolean;
+        issues: string[];
+    };
+    stubDetection?: {
+        hasStubs: boolean;
+        stubs: string[];
+    };
+    wasMarkdownWrapped?: boolean;
+}
+/**
+ * Full validation pipeline for agent output
+ */
+export declare function validateAgentOutput(raw: string, projectRoot: string, options?: {
+    strictMarkdown?: boolean;
+}): FullValidationResult;
+/**
+ * Quick check if output is markdown-wrapped (for error messages)
+ */
+export declare function isMarkdownWrapped(raw: string): boolean;
+//# sourceMappingURL=format-validator.d.ts.map