guardrail-core 1.0.0

package/dist/verified-autofix/__tests__/format-validator.test.js

@@ -0,0 +1,285 @@
+"use strict";
+/**
+ * Format Validator Tests
+ *
+ * Tests for the verified autofix format validation:
+ * - JSON shape validation
+ * - Unified diff parsing
+ * - Path safety checks
+ * - Stub detection
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const format_validator_1 = require("../format-validator");
+describe('stripMarkdownFences', () => {
+    it('removes ```json wrapper', () => {
+        const raw = '```json\n{"format":"guardrail-v1"}\n```';
+        expect((0, format_validator_1.stripMarkdownFences)(raw)).toBe('{"format":"guardrail-v1"}');
+    });
+    it('removes ``` wrapper without language', () => {
+        const raw = '```\n{"format":"guardrail-v1"}\n```';
+        expect((0, format_validator_1.stripMarkdownFences)(raw)).toBe('{"format":"guardrail-v1"}');
+    });
+    it('handles partial fences', () => {
+        const raw = '```json\n{"format":"guardrail-v1"}';
+        expect((0, format_validator_1.stripMarkdownFences)(raw)).toBe('{"format":"guardrail-v1"}');
+    });
+    it('returns unchanged if no fences', () => {
+        const raw = '{"format":"guardrail-v1"}';
+        expect((0, format_validator_1.stripMarkdownFences)(raw)).toBe('{"format":"guardrail-v1"}');
+    });
+});
+describe('isMarkdownWrapped', () => {
+    it('detects ```json wrapper', () => {
+        expect((0, format_validator_1.isMarkdownWrapped)('```json\n{}\n```')).toBe(true);
+    });
+    it('detects ``` wrapper', () => {
+        expect((0, format_validator_1.isMarkdownWrapped)('```\n{}\n```')).toBe(true);
+    });
+    it('returns false for plain JSON', () => {
+        expect((0, format_validator_1.isMarkdownWrapped)('{}')).toBe(false);
+    });
+});
+describe('validateJsonShape', () => {
+    it('accepts valid guardrail-v1 output', () => {
+        const valid = {
+            format: 'guardrail-v1',
+            diff: '--- a/file.ts\n+++ b/file.ts\n@@ -1,1 +1,1 @@\n-old\n+new',
+            commands: ['npm test'],
+            tests: ['test/file.test.ts'],
+            notes: 'Fixed the bug',
+        };
+        const result = (0, format_validator_1.validateJsonShape)(valid);
+        expect(result.valid).toBe(true);
+        expect(result.errors).toHaveLength(0);
+        expect(result.sanitized).toBeDefined();
+    });
+    it('rejects missing format field', () => {
+        const invalid = {
+            diff: '',
+            commands: [],
+            tests: [],
+            notes: '',
+        };
+        const result = (0, format_validator_1.validateJsonShape)(invalid);
+        expect(result.valid).toBe(false);
+        expect(result.errors).toContain(expect.stringContaining('format'));
+    });
+    it('rejects wrong format value', () => {
+        const invalid = {
+            format: 'other-format',
+            diff: '',
+            commands: [],
+            tests: [],
+            notes: '',
+        };
+        const result = (0, format_validator_1.validateJsonShape)(invalid);
+        expect(result.valid).toBe(false);
+        expect(result.errors[0]).toContain('guardrail-v1');
+    });
+    it('rejects non-string diff', () => {
+        const invalid = {
+            format: 'guardrail-v1',
+            diff: 123,
+            commands: [],
+            tests: [],
+            notes: '',
+        };
+        const result = (0, format_validator_1.validateJsonShape)(invalid);
+        expect(result.valid).toBe(false);
+        expect(result.errors).toContain(expect.stringContaining('diff'));
+    });
+    it('rejects non-array commands', () => {
+        const invalid = {
+            format: 'guardrail-v1',
+            diff: '',
+            commands: 'npm test',
+            tests: [],
+            notes: '',
+        };
+        const result = (0, format_validator_1.validateJsonShape)(invalid);
+        expect(result.valid).toBe(false);
+        expect(result.errors).toContain(expect.stringContaining('commands'));
+    });
+});
+describe('validateUnifiedDiff', () => {
+    it('parses valid unified diff', () => {
+        const diff = `--- a/src/file.ts
++++ b/src/file.ts
+@@ -1,3 +1,4 @@
+ const x = 1;
+-const y = 2;
++const y = 3;
++const z = 4;
+ export { x, y };`;
+        const result = (0, format_validator_1.validateUnifiedDiff)(diff);
+        expect(result.valid).toBe(true);
+        expect(result.filesAffected).toContain('src/file.ts');
+        expect(result.hunks).toHaveLength(1);
+    });
+    it('handles empty diff', () => {
+        const result = (0, format_validator_1.validateUnifiedDiff)('');
+        expect(result.valid).toBe(true);
+        expect(result.hunks).toHaveLength(0);
+    });
+    it('handles multi-file diff', () => {
+        const diff = `diff --git a/file1.ts b/file1.ts
+--- a/file1.ts
++++ b/file1.ts
+@@ -1,1 +1,1 @@
+-old1
++new1
+diff --git a/file2.ts b/file2.ts
+--- a/file2.ts
++++ b/file2.ts
+@@ -1,1 +1,1 @@
+-old2
++new2`;
+        const result = (0, format_validator_1.validateUnifiedDiff)(diff);
+        expect(result.valid).toBe(true);
+        expect(result.filesAffected).toContain('file1.ts');
+        expect(result.filesAffected).toContain('file2.ts');
+    });
+});
+describe('validatePathSafety', () => {
+    const projectRoot = '/home/user/project';
+    it('accepts paths within project', () => {
+        const paths = ['src/file.ts', 'lib/utils.js', 'package.json'];
+        const result = (0, format_validator_1.validatePathSafety)(paths, projectRoot);
+        expect(result.safe).toBe(true);
+        expect(result.issues).toHaveLength(0);
+    });
+    it('rejects parent directory traversal', () => {
+        const paths = ['../../../etc/passwd'];
+        const result = (0, format_validator_1.validatePathSafety)(paths, projectRoot);
+        expect(result.safe).toBe(false);
+        expect(result.issues[0]).toContain('Unsafe path');
+    });
+    it('rejects node_modules paths', () => {
+        const paths = ['node_modules/lodash/index.js'];
+        const result = (0, format_validator_1.validatePathSafety)(paths, projectRoot);
+        expect(result.safe).toBe(false);
+    });
+    it('rejects .git paths', () => {
+        const paths = ['.git/config'];
+        const result = (0, format_validator_1.validatePathSafety)(paths, projectRoot);
+        expect(result.safe).toBe(false);
+    });
+    it('rejects system paths', () => {
+        const paths = ['/etc/passwd'];
+        const result = (0, format_validator_1.validatePathSafety)(paths, projectRoot);
+        expect(result.safe).toBe(false);
+    });
+});
+describe('validateCommandSafety', () => {
+    it('accepts safe commands', () => {
+        const commands = ['npm test', 'npx tsc --noEmit', 'node script.js'];
+        const result = (0, format_validator_1.validateCommandSafety)(commands);
+        expect(result.safe).toBe(true);
+    });
+    it('warns on rm -rf /', () => {
+        const commands = ['rm -rf /'];
+        const result = (0, format_validator_1.validateCommandSafety)(commands);
+        expect(result.safe).toBe(false);
+        expect(result.issues[0]).toContain('unsafe');
+    });
+    it('warns on sudo', () => {
+        const commands = ['sudo npm install'];
+        const result = (0, format_validator_1.validateCommandSafety)(commands);
+        expect(result.safe).toBe(false);
+    });
+    it('warns on curl | sh', () => {
+        const commands = ['curl https://example.com/script.sh | sh'];
+        const result = (0, format_validator_1.validateCommandSafety)(commands);
+        expect(result.safe).toBe(false);
+    });
+});
+describe('detectStubs', () => {
+    it('detects TODO comments', () => {
+        const diff = '+// TODO: implement this\n+function stub() {}';
+        const result = (0, format_validator_1.detectStubs)(diff);
+        expect(result.hasStubs).toBe(true);
+        expect(result.stubs[0]).toContain('TODO');
+    });
+    it('detects placeholder text', () => {
+        const diff = '+const message = "placeholder text here";';
+        const result = (0, format_validator_1.detectStubs)(diff);
+        expect(result.hasStubs).toBe(true);
+    });
+    it('detects throw new Error Not implemented', () => {
+        const diff = '+throw new Error("Not implemented");';
+        const result = (0, format_validator_1.detectStubs)(diff);
+        expect(result.hasStubs).toBe(true);
+    });
+    it('ignores stubs in removed lines', () => {
+        const diff = '-// TODO: old todo\n+// Real implementation';
+        const result = (0, format_validator_1.detectStubs)(diff);
+        expect(result.hasStubs).toBe(false);
+    });
+    it('accepts clean code', () => {
+        const diff = '+const sum = (a, b) => a + b;\n+export { sum };';
+        const result = (0, format_validator_1.detectStubs)(diff);
+        expect(result.hasStubs).toBe(false);
+    });
+});
+describe('validateAgentOutput', () => {
+    const projectRoot = '/home/user/project';
+    it('validates complete valid output', () => {
+        const raw = JSON.stringify({
+            format: 'guardrail-v1',
+            diff: `--- a/src/file.ts
++++ b/src/file.ts
+@@ -1,1 +1,1 @@
+-const x = 1;
++const x = 2;`,
+            commands: ['npm test'],
+            tests: ['test/file.test.ts'],
+            notes: 'Incremented x',
+        });
+        const result = (0, format_validator_1.validateAgentOutput)(raw, projectRoot);
+        expect(result.valid).toBe(true);
+        expect(result.output).toBeDefined();
+    });
+    it('strips markdown fences and validates', () => {
+        const raw = '```json\n' + JSON.stringify({
+            format: 'guardrail-v1',
+            diff: '',
+            commands: [],
+            tests: [],
+            notes: 'No changes needed',
+        }) + '\n```';
+        const result = (0, format_validator_1.validateAgentOutput)(raw, projectRoot);
+        expect(result.valid).toBe(true);
+    });
+    it('rejects invalid JSON', () => {
+        const result = (0, format_validator_1.validateAgentOutput)('not json', projectRoot);
+        expect(result.valid).toBe(false);
+        expect(result.errors[0]).toContain('Invalid JSON');
+    });
+    it('rejects output with stubs', () => {
+        const raw = JSON.stringify({
+            format: 'guardrail-v1',
+            diff: '+// TODO: implement this',
+            commands: [],
+            tests: [],
+            notes: '',
+        });
+        const result = (0, format_validator_1.validateAgentOutput)(raw, projectRoot);
+        expect(result.valid).toBe(false);
+        expect(result.errors.some(e => e.includes('Stub'))).toBe(true);
+    });
+    it('rejects output with unsafe paths', () => {
+        const raw = JSON.stringify({
+            format: 'guardrail-v1',
+            diff: `--- a/../../../etc/passwd
++++ b/../../../etc/passwd
+@@ -1,1 +1,1 @@
+-root
++hacked`,
+            commands: [],
+            tests: [],
+            notes: '',
+        });
+        const result = (0, format_validator_1.validateAgentOutput)(raw, projectRoot);
+        expect(result.valid).toBe(false);
+    });
+});

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

@@ -0,0 +1,11 @@
+/**
+ * Pipeline Tests - Verified AutoFix Pipeline
+ *
+ * Tests for the full verification pipeline:
+ * - Format validation stage
+ * - Diff application stage
+ * - Verification stage (typecheck, build, tests)
+ * - Top 3 failure context extraction
+ */
+export {};
+//# sourceMappingURL=pipeline.test.d.ts.map

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

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

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

@@ -0,0 +1,389 @@
+"use strict";
+/**
+ * Pipeline Tests - Verified AutoFix Pipeline
+ *
+ * Tests for the full verification pipeline:
+ * - Format validation stage
+ * - Diff application stage
+ * - Verification stage (typecheck, build, tests)
+ * - 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 pipeline_1 = require("../pipeline");
+const format_validator_1 = require("../format-validator");
+describe('VerifiedAutofixPipeline', () => {
+    let tempDir;
+    let pipeline;
+    beforeEach(async () => {
+        tempDir = await fs.promises.mkdtemp(path.join(os.tmpdir(), 'pipeline-test-'));
+        pipeline = new pipeline_1.VerifiedAutofixPipeline();
+        // 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"',
+                test: 'echo "test"',
+            },
+        }));
+    });
+    afterEach(async () => {
+        await fs.promises.rm(tempDir, { recursive: true, force: true });
+    });
+    describe('validation stage', () => {
+        it('rejects missing agent output file', async () => {
+            const result = await pipeline.run({
+                projectPath: tempDir,
+                agentOutputFile: '/nonexistent/file.json',
+                skipEntitlements: true,
+            });
+            expect(result.success).toBe(false);
+            expect(result.stage).toBe('validate');
+            expect(result.errors.some(e => e.includes('not found'))).toBe(true);
+        });
+        it('rejects invalid JSON in agent output', async () => {
+            const outputFile = path.join(tempDir, 'output.json');
+            await fs.promises.writeFile(outputFile, 'not valid json');
+            const result = await pipeline.run({
+                projectPath: tempDir,
+                agentOutputFile: outputFile,
+                skipEntitlements: true,
+            });
+            expect(result.success).toBe(false);
+            expect(result.errors.some(e => e.includes('Invalid JSON'))).toBe(true);
+        });
+        it('rejects wrong format field', async () => {
+            const outputFile = path.join(tempDir, 'output.json');
+            await fs.promises.writeFile(outputFile, JSON.stringify({
+                format: 'wrong-format',
+                diff: '',
+                commands: [],
+                tests: [],
+                notes: '',
+            }));
+            const result = await pipeline.run({
+                projectPath: tempDir,
+                agentOutputFile: outputFile,
+                skipEntitlements: true,
+            });
+            expect(result.success).toBe(false);
+            expect(result.errors.some(e => e.includes('guardrail-v1'))).toBe(true);
+        });
+        it('accepts valid guardrail-v1 output with empty diff', async () => {
+            const outputFile = path.join(tempDir, 'output.json');
+            await fs.promises.writeFile(outputFile, JSON.stringify({
+                format: 'guardrail-v1',
+                diff: '',
+                commands: [],
+                tests: [],
+                notes: 'No changes needed',
+            }));
+            const result = await pipeline.run({
+                projectPath: tempDir,
+                agentOutputFile: outputFile,
+                skipEntitlements: true,
+            });
+            expect(result.success).toBe(true);
+            expect(result.stage).toBe('done');
+        });
+        it('strips markdown fences and warns', async () => {
+            const outputFile = path.join(tempDir, 'output.json');
+            await fs.promises.writeFile(outputFile, '```json\n' + JSON.stringify({
+                format: 'guardrail-v1',
+                diff: '',
+                commands: [],
+                tests: [],
+                notes: '',
+            }) + '\n```');
+            const result = await pipeline.run({
+                projectPath: tempDir,
+                agentOutputFile: outputFile,
+                skipEntitlements: true,
+            });
+            expect(result.success).toBe(true);
+            expect(result.warnings.some(w => w.includes('markdown'))).toBe(true);
+        });
+    });
+    describe('stub detection', () => {
+        it('blocks TODO comments in diff', async () => {
+            const outputFile = path.join(tempDir, 'output.json');
+            await fs.promises.writeFile(outputFile, JSON.stringify({
+                format: 'guardrail-v1',
+                diff: `--- a/src/file.ts
++++ b/src/file.ts
+@@ -1,1 +1,2 @@
+ const x = 1;
++// TODO: implement this`,
+                commands: [],
+                tests: [],
+                notes: '',
+            }));
+            const result = await pipeline.run({
+                projectPath: tempDir,
+                agentOutputFile: outputFile,
+                skipEntitlements: true,
+            });
+            expect(result.success).toBe(false);
+            expect(result.errors.some(e => e.includes('Stub'))).toBe(true);
+        });
+        it('blocks placeholder text in diff', async () => {
+            const outputFile = path.join(tempDir, 'output.json');
+            await fs.promises.writeFile(outputFile, JSON.stringify({
+                format: 'guardrail-v1',
+                diff: `--- a/src/file.ts
++++ b/src/file.ts
+@@ -1,1 +1,2 @@
+ const x = 1;
++const message = "placeholder content here";`,
+                commands: [],
+                tests: [],
+                notes: '',
+            }));
+            const result = await pipeline.run({
+                projectPath: tempDir,
+                agentOutputFile: outputFile,
+                skipEntitlements: true,
+            });
+            expect(result.success).toBe(false);
+            expect(result.errors.some(e => e.includes('Stub') || e.includes('placeholder'))).toBe(true);
+        });
+        it('allows clean code without stubs', async () => {
+            const outputFile = path.join(tempDir, 'output.json');
+            await fs.promises.writeFile(outputFile, JSON.stringify({
+                format: 'guardrail-v1',
+                diff: `--- a/src/file.ts
++++ b/src/file.ts
+@@ -1,1 +1,2 @@
+ const x = 1;
++const y = x + 1;`,
+                commands: [],
+                tests: [],
+                notes: '',
+            }));
+            // Create the source file
+            await fs.promises.mkdir(path.join(tempDir, 'src'), { recursive: true });
+            await fs.promises.writeFile(path.join(tempDir, 'src', 'file.ts'), 'const x = 1;\n');
+            const result = await pipeline.run({
+                projectPath: tempDir,
+                agentOutputFile: outputFile,
+                dryRun: true,
+                skipEntitlements: true,
+            });
+            // Should pass validation (stub detection at least)
+            expect(result.validation?.stubDetection?.hasStubs).toBe(false);
+        });
+    });
+    describe('path safety', () => {
+        it('blocks parent directory traversal', async () => {
+            const outputFile = path.join(tempDir, 'output.json');
+            await fs.promises.writeFile(outputFile, JSON.stringify({
+                format: 'guardrail-v1',
+                diff: `--- a/../../../etc/passwd
++++ b/../../../etc/passwd
+@@ -1,1 +1,1 @@
+-root
++hacked`,
+                commands: [],
+                tests: [],
+                notes: '',
+            }));
+            const result = await pipeline.run({
+                projectPath: tempDir,
+                agentOutputFile: outputFile,
+                skipEntitlements: true,
+            });
+            expect(result.success).toBe(false);
+            expect(result.errors.some(e => e.includes('Unsafe') || e.includes('path'))).toBe(true);
+        });
+        it('blocks node_modules modifications', async () => {
+            const outputFile = path.join(tempDir, 'output.json');
+            await fs.promises.writeFile(outputFile, JSON.stringify({
+                format: 'guardrail-v1',
+                diff: `--- a/node_modules/lodash/index.js
++++ b/node_modules/lodash/index.js
+@@ -1,1 +1,1 @@
+-module.exports = {};
++module.exports = { hacked: true };`,
+                commands: [],
+                tests: [],
+                notes: '',
+            }));
+            const result = await pipeline.run({
+                projectPath: tempDir,
+                agentOutputFile: outputFile,
+                skipEntitlements: true,
+            });
+            expect(result.success).toBe(false);
+        });
+    });
+    describe('dry run mode', () => {
+        it('validates without applying changes', async () => {
+            const outputFile = path.join(tempDir, 'output.json');
+            await fs.promises.writeFile(outputFile, JSON.stringify({
+                format: 'guardrail-v1',
+                diff: `--- a/src/file.ts
++++ b/src/file.ts
+@@ -1,1 +1,2 @@
+ const x = 1;
++const y = 2;`,
+                commands: ['npm test'],
+                tests: ['test/file.test.ts'],
+                notes: 'Added y constant',
+            }));
+            // Create source file
+            await fs.promises.mkdir(path.join(tempDir, 'src'), { recursive: true });
+            await fs.promises.writeFile(path.join(tempDir, 'src', 'file.ts'), 'const x = 1;\n');
+            const result = await pipeline.run({
+                projectPath: tempDir,
+                agentOutputFile: outputFile,
+                dryRun: true,
+                skipEntitlements: true,
+            });
+            expect(result.success).toBe(true);
+            expect(result.stage).toBe('done');
+            // File should NOT be modified in dry run
+            const content = await fs.promises.readFile(path.join(tempDir, 'src', 'file.ts'), 'utf8');
+            expect(content).toBe('const x = 1;\n');
+        });
+    });
+    describe('progress callbacks', () => {
+        it('calls onProgress for each stage', async () => {
+            const outputFile = path.join(tempDir, 'output.json');
+            await fs.promises.writeFile(outputFile, JSON.stringify({
+                format: 'guardrail-v1',
+                diff: '',
+                commands: [],
+                tests: [],
+                notes: '',
+            }));
+            const stages = [];
+            await pipeline.run({
+                projectPath: tempDir,
+                agentOutputFile: outputFile,
+                skipEntitlements: true,
+                onProgress: (stage) => {
+                    stages.push(stage);
+                },
+            });
+            expect(stages).toContain('init');
+            expect(stages).toContain('validate');
+            expect(stages).toContain('done');
+        });
+    });
+});
+describe('validateAgentOutput strictMarkdown option', () => {
+    const projectRoot = '/tmp/project';
+    it('rejects markdown in strict mode', () => {
+        const raw = '```json\n{"format":"guardrail-v1","diff":"","commands":[],"tests":[],"notes":""}\n```';
+        const result = (0, format_validator_1.validateAgentOutput)(raw, projectRoot, { strictMarkdown: true });
+        expect(result.valid).toBe(false);
+        expect(result.wasMarkdownWrapped).toBe(true);
+        expect(result.errors[0]).toContain('markdown');
+    });
+    it('accepts and strips markdown in forgiving mode', () => {
+        const raw = '```json\n{"format":"guardrail-v1","diff":"","commands":[],"tests":[],"notes":""}\n```';
+        const result = (0, format_validator_1.validateAgentOutput)(raw, projectRoot);
+        expect(result.valid).toBe(true);
+        expect(result.wasMarkdownWrapped).toBe(true);
+        expect(result.warnings.some(w => w.includes('markdown'))).toBe(true);
+    });
+    it('accepts raw JSON without warnings', () => {
+        const raw = '{"format":"guardrail-v1","diff":"","commands":[],"tests":[],"notes":""}';
+        const result = (0, format_validator_1.validateAgentOutput)(raw, projectRoot);
+        expect(result.valid).toBe(true);
+        expect(result.wasMarkdownWrapped).toBe(false);
+        expect(result.warnings.filter(w => w.includes('markdown'))).toHaveLength(0);
+    });
+});
+describe('formatPipelineResult', () => {
+    it('formats successful result', () => {
+        const result = {
+            success: true,
+            stage: 'done',
+            duration: 1234,
+            filesModified: ['src/file.ts'],
+            errors: [],
+            warnings: [],
+            failureContext: [],
+        };
+        const output = (0, pipeline_1.formatPipelineResult)(result);
+        expect(output).toContain('SUCCESSFUL');
+        expect(output).toContain('src/file.ts');
+        expect(output).toContain('1234');
+    });
+    it('formats failed result with top 3 failures', () => {
+        const result = {
+            success: false,
+            stage: 'typecheck',
+            duration: 500,
+            filesModified: [],
+            errors: ['TypeScript error'],
+            warnings: [],
+            failureContext: [
+                'error TS2322: Type mismatch',
+                'error TS2345: Argument type',
+                'error TS2339: Property does not exist',
+                'error TS2304: Cannot find name', // This 4th one should be cut off
+            ],
+        };
+        const output = (0, pipeline_1.formatPipelineResult)(result);
+        expect(output).toContain('FAILED');
+        expect(output).toContain('TS2322');
+        expect(output).toContain('TS2345');
+        expect(output).toContain('TS2339');
+    });
+});
+describe('formatPipelineResultJson', () => {
+    it('outputs valid JSON', () => {
+        const result = {
+            success: true,
+            stage: 'done',
+            duration: 100,
+            filesModified: ['a.ts'],
+            errors: [],
+            warnings: ['warn1'],
+            failureContext: [],
+        };
+        const json = (0, pipeline_1.formatPipelineResultJson)(result);
+        const parsed = JSON.parse(json);
+        expect(parsed.success).toBe(true);
+        expect(parsed.filesModified).toEqual(['a.ts']);
+        expect(parsed.warnings).toEqual(['warn1']);
+    });
+});