@renseiai/agentfactory 0.8.19 → 0.8.21

package/dist/src/orchestrator/quality-baseline.test.js

@@ -0,0 +1,448 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { captureQualityBaseline, computeQualityDelta, formatQualityReport, parseVitestJson, countTypescriptErrors, loadBaseline, saveBaseline, } from './quality-baseline.js';
+// Mock child_process and fs
+vi.mock('node:child_process', () => ({
+    execSync: vi.fn(),
+}));
+vi.mock('node:fs', () => ({
+    readFileSync: vi.fn(),
+    writeFileSync: vi.fn(),
+    existsSync: vi.fn(),
+}));
+import { execSync } from 'node:child_process';
+import { readFileSync, writeFileSync, existsSync } from 'node:fs';
+const mockExecSync = vi.mocked(execSync);
+const mockReadFileSync = vi.mocked(readFileSync);
+const mockWriteFileSync = vi.mocked(writeFileSync);
+const mockExistsSync = vi.mocked(existsSync);
+beforeEach(() => {
+    vi.resetAllMocks();
+});
+// ---------------------------------------------------------------------------
+// captureQualityBaseline
+// ---------------------------------------------------------------------------
+describe('captureQualityBaseline', () => {
+    it('captures test counts from vitest JSON output', () => {
+        // git rev-parse HEAD
+        mockExecSync.mockReturnValueOnce('abc123\n');
+        // test command with --reporter=json
+        mockExecSync.mockReturnValueOnce(JSON.stringify({
+            numTotalTests: 100,
+            numPassedTests: 98,
+            numFailedTests: 2,
+        }));
+        // typecheck command
+        mockExecSync.mockReturnValueOnce('');
+        // no lint command configured → skipped
+        const baseline = captureQualityBaseline('/work', {
+            testCommand: 'pnpm test',
+            validateCommand: 'pnpm typecheck',
+        });
+        expect(baseline.commitSha).toBe('abc123');
+        expect(baseline.tests.total).toBe(100);
+        expect(baseline.tests.passed).toBe(98);
+        expect(baseline.tests.failed).toBe(2);
+        expect(baseline.typecheck.errorCount).toBe(0);
+        expect(baseline.typecheck.exitCode).toBe(0);
+    });
+    it('falls back to text parsing when JSON reporter fails', () => {
+        // git rev-parse HEAD
+        mockExecSync.mockReturnValueOnce('abc123\n');
+        // JSON reporter fails
+        mockExecSync.mockImplementationOnce(() => { throw new Error('json reporter not found'); });
+        // text output fallback
+        mockExecSync.mockReturnValueOnce('Tests  42 passed | 3 failed | 45 total');
+        // typecheck
+        mockExecSync.mockReturnValueOnce('');
+        const baseline = captureQualityBaseline('/work', {});
+        expect(baseline.tests.total).toBe(45);
+        expect(baseline.tests.passed).toBe(42);
+        expect(baseline.tests.failed).toBe(3);
+    });
+    it('captures typecheck errors from stderr', () => {
+        // git rev-parse HEAD
+        mockExecSync.mockReturnValueOnce('abc123\n');
+        // test JSON reporter
+        mockExecSync.mockReturnValueOnce(JSON.stringify({ numTotalTests: 10, numPassedTests: 10, numFailedTests: 0 }));
+        // typecheck fails
+        const tscError = new Error('tsc failed');
+        tscError.stdout = '';
+        tscError.stderr = 'src/a.ts(1,1): error TS2304: Cannot find name\nsrc/b.ts(5,3): error TS2345: Argument of type';
+        tscError.status = 2;
+        mockExecSync.mockImplementationOnce(() => { throw tscError; });
+        const baseline = captureQualityBaseline('/work', {});
+        expect(baseline.typecheck.errorCount).toBe(2);
+        expect(baseline.typecheck.exitCode).toBe(2);
+    });
+    it('handles complete test failure gracefully', () => {
+        // git rev-parse HEAD
+        mockExecSync.mockReturnValueOnce('abc123\n');
+        // JSON reporter fails
+        mockExecSync.mockImplementationOnce(() => { throw new Error('crash'); });
+        // text fallback also fails
+        mockExecSync.mockImplementationOnce(() => { throw new Error('crash'); });
+        // typecheck passes
+        mockExecSync.mockReturnValueOnce('');
+        const baseline = captureQualityBaseline('/work', {});
+        // Should record at least 1 failure, not throw
+        expect(baseline.tests.failed).toBeGreaterThanOrEqual(1);
+    });
+    it('returns unknown commit SHA when git fails', () => {
+        mockExecSync.mockImplementationOnce(() => { throw new Error('not a git repo'); });
+        // JSON reporter
+        mockExecSync.mockReturnValueOnce(JSON.stringify({ numTotalTests: 1, numPassedTests: 1, numFailedTests: 0 }));
+        // typecheck
+        mockExecSync.mockReturnValueOnce('');
+        const baseline = captureQualityBaseline('/work', {});
+        expect(baseline.commitSha).toBe('unknown');
+    });
+    it('captures lint metrics when lintCommand is provided', () => {
+        mockExecSync.mockReturnValueOnce('abc123\n');
+        mockExecSync.mockReturnValueOnce(JSON.stringify({ numTotalTests: 5, numPassedTests: 5, numFailedTests: 0 }));
+        mockExecSync.mockReturnValueOnce('');
+        // lint command output
+        mockExecSync.mockReturnValueOnce('\n✖ 10 problems (6 errors, 4 warnings)\n');
+        const baseline = captureQualityBaseline('/work', {
+            lintCommand: 'pnpm lint',
+        });
+        expect(baseline.lint.errorCount).toBe(6);
+        expect(baseline.lint.warningCount).toBe(4);
+    });
+    it('returns zero lint counts when no lintCommand is configured', () => {
+        mockExecSync.mockReturnValueOnce('abc123\n');
+        mockExecSync.mockReturnValueOnce(JSON.stringify({ numTotalTests: 1, numPassedTests: 1, numFailedTests: 0 }));
+        mockExecSync.mockReturnValueOnce('');
+        const baseline = captureQualityBaseline('/work', {});
+        expect(baseline.lint.errorCount).toBe(0);
+        expect(baseline.lint.warningCount).toBe(0);
+    });
+    it('returns errorCount=1 when typecheck exits non-zero but has no parseable errors', () => {
+        mockExecSync.mockReturnValueOnce('abc123\n');
+        mockExecSync.mockReturnValueOnce(JSON.stringify({ numTotalTests: 1, numPassedTests: 1, numFailedTests: 0 }));
+        const tscError = new Error('tsc failed');
+        tscError.stdout = '';
+        tscError.stderr = 'Some unparseable error output';
+        tscError.status = 1;
+        mockExecSync.mockImplementationOnce(() => { throw tscError; });
+        const baseline = captureQualityBaseline('/work', {});
+        expect(baseline.typecheck.errorCount).toBe(1);
+        expect(baseline.typecheck.exitCode).toBe(1);
+    });
+    it('uses custom packageManager for default commands', () => {
+        mockExecSync.mockReturnValueOnce('abc123\n');
+        // JSON reporter with npm
+        mockExecSync.mockReturnValueOnce(JSON.stringify({ numTotalTests: 1, numPassedTests: 1, numFailedTests: 0 }));
+        // typecheck
+        mockExecSync.mockReturnValueOnce('');
+        captureQualityBaseline('/work', { packageManager: 'npm' });
+        // First call after git rev-parse should use npm for test command
+        const testCall = mockExecSync.mock.calls[1];
+        expect(testCall[0]).toContain('npm test');
+    });
+    it('captures lint errors from failing lint command', () => {
+        mockExecSync.mockReturnValueOnce('abc123\n');
+        mockExecSync.mockReturnValueOnce(JSON.stringify({ numTotalTests: 1, numPassedTests: 1, numFailedTests: 0 }));
+        mockExecSync.mockReturnValueOnce('');
+        // lint command fails
+        const lintError = new Error('lint failed');
+        lintError.stdout = '\n✖ 3 problems (3 errors, 0 warnings)\n';
+        lintError.stderr = '';
+        mockExecSync.mockImplementationOnce(() => { throw lintError; });
+        const baseline = captureQualityBaseline('/work', { lintCommand: 'pnpm lint' });
+        expect(baseline.lint.errorCount).toBe(3);
+        expect(baseline.lint.warningCount).toBe(0);
+    });
+});
+// ---------------------------------------------------------------------------
+// computeQualityDelta
+// ---------------------------------------------------------------------------
+describe('computeQualityDelta', () => {
+    const makeBaseline = (overrides) => ({
+        timestamp: '2026-01-01T00:00:00Z',
+        commitSha: 'base',
+        tests: { total: 100, passed: 95, failed: 5, skipped: 0 },
+        typecheck: { errorCount: 3, exitCode: 0 },
+        lint: { errorCount: 2, warningCount: 10 },
+        ...overrides,
+    });
+    it('passes when agent improves all metrics', () => {
+        const baseline = makeBaseline();
+        const current = makeBaseline({
+            tests: { total: 105, passed: 102, failed: 3, skipped: 0 },
+            typecheck: { errorCount: 1, exitCode: 0 },
+            lint: { errorCount: 0, warningCount: 5 },
+        });
+        const delta = computeQualityDelta(baseline, current);
+        expect(delta.passed).toBe(true);
+        expect(delta.testFailuresDelta).toBe(-2);
+        expect(delta.typeErrorsDelta).toBe(-2);
+        expect(delta.lintErrorsDelta).toBe(-2);
+        expect(delta.testCountDelta).toBe(5);
+    });
+    it('fails when agent introduces new test failures', () => {
+        const baseline = makeBaseline();
+        const current = makeBaseline({
+            tests: { total: 100, passed: 92, failed: 8, skipped: 0 },
+        });
+        const delta = computeQualityDelta(baseline, current);
+        expect(delta.passed).toBe(false);
+        expect(delta.testFailuresDelta).toBe(3);
+    });
+    it('fails when agent introduces new typecheck errors', () => {
+        const baseline = makeBaseline();
+        const current = makeBaseline({
+            typecheck: { errorCount: 5, exitCode: 1 },
+        });
+        const delta = computeQualityDelta(baseline, current);
+        expect(delta.passed).toBe(false);
+        expect(delta.typeErrorsDelta).toBe(2);
+    });
+    it('fails when agent introduces new lint errors', () => {
+        const baseline = makeBaseline();
+        const current = makeBaseline({
+            lint: { errorCount: 4, warningCount: 10 },
+        });
+        const delta = computeQualityDelta(baseline, current);
+        expect(delta.passed).toBe(false);
+        expect(delta.lintErrorsDelta).toBe(2);
+    });
+    it('passes when baseline and current are identical', () => {
+        const baseline = makeBaseline();
+        const current = makeBaseline();
+        const delta = computeQualityDelta(baseline, current);
+        expect(delta.passed).toBe(true);
+        expect(delta.testFailuresDelta).toBe(0);
+        expect(delta.typeErrorsDelta).toBe(0);
+        expect(delta.lintErrorsDelta).toBe(0);
+        expect(delta.testCountDelta).toBe(0);
+    });
+    it('tracks test removal as negative testCountDelta', () => {
+        const baseline = makeBaseline();
+        const current = makeBaseline({
+            tests: { total: 90, passed: 90, failed: 0, skipped: 0 },
+        });
+        const delta = computeQualityDelta(baseline, current);
+        expect(delta.passed).toBe(true); // fewer failures is good
+        expect(delta.testCountDelta).toBe(-10); // but removing tests is a warning
+    });
+});
+// ---------------------------------------------------------------------------
+// formatQualityReport
+// ---------------------------------------------------------------------------
+describe('formatQualityReport', () => {
+    const makeBaseline = () => ({
+        timestamp: '2026-01-01T00:00:00Z',
+        commitSha: 'base',
+        tests: { total: 100, passed: 95, failed: 5, skipped: 0 },
+        typecheck: { errorCount: 3, exitCode: 0 },
+        lint: { errorCount: 2, warningCount: 10 },
+    });
+    it('formats a passing report', () => {
+        const baseline = makeBaseline();
+        const current = { ...makeBaseline(), tests: { total: 100, passed: 98, failed: 2, skipped: 0 } };
+        const delta = computeQualityDelta(baseline, current);
+        const report = formatQualityReport(baseline, current, delta);
+        expect(report).toContain('**PASSED**');
+        expect(report).toContain('Test failures');
+        expect(report).toContain('Typecheck errors');
+    });
+    it('formats a failing report', () => {
+        const baseline = makeBaseline();
+        const current = { ...makeBaseline(), tests: { total: 100, passed: 90, failed: 10, skipped: 0 } };
+        const delta = computeQualityDelta(baseline, current);
+        const report = formatQualityReport(baseline, current, delta);
+        expect(report).toContain('**FAILED**');
+        expect(report).toContain('+5');
+    });
+    it('warns about removed tests', () => {
+        const baseline = makeBaseline();
+        const current = { ...makeBaseline(), tests: { total: 80, passed: 80, failed: 0, skipped: 0 } };
+        const delta = computeQualityDelta(baseline, current);
+        const report = formatQualityReport(baseline, current, delta);
+        expect(report).toContain('20 test(s) were removed');
+    });
+});
+// ---------------------------------------------------------------------------
+// parseVitestJson
+// ---------------------------------------------------------------------------
+describe('parseVitestJson', () => {
+    it('parses standard vitest JSON output', () => {
+        const json = JSON.stringify({
+            numTotalTests: 50,
+            numPassedTests: 48,
+            numFailedTests: 2,
+        });
+        const result = parseVitestJson(json);
+        expect(result).toEqual({ total: 50, passed: 48, failed: 2, skipped: 0 });
+    });
+    it('handles JSON with non-JSON prefix', () => {
+        const output = 'Some vitest output\n' + JSON.stringify({
+            numTotalTests: 10,
+            numPassedTests: 10,
+            numFailedTests: 0,
+        });
+        const result = parseVitestJson(output);
+        expect(result?.total).toBe(10);
+    });
+    it('returns null for non-JSON output', () => {
+        expect(parseVitestJson('not json at all')).toBeNull();
+    });
+    it('returns null for empty string', () => {
+        expect(parseVitestJson('')).toBeNull();
+    });
+    it('parses vitest v2+ format with testResults array', () => {
+        const output = JSON.stringify({
+            testResults: [
+                {
+                    assertionResults: [
+                        { status: 'passed' },
+                        { status: 'passed' },
+                        { status: 'failed' },
+                    ],
+                },
+                {
+                    assertionResults: [
+                        { status: 'passed' },
+                    ],
+                },
+            ],
+        });
+        const result = parseVitestJson(output);
+        expect(result).toEqual({ total: 4, passed: 3, failed: 1, skipped: 0 });
+    });
+    it('returns null for JSON without recognized fields', () => {
+        const output = JSON.stringify({ unrelated: 'data' });
+        expect(parseVitestJson(output)).toBeNull();
+    });
+    it('computes skipped count correctly', () => {
+        const json = JSON.stringify({
+            numTotalTests: 20,
+            numPassedTests: 15,
+            numFailedTests: 2,
+        });
+        const result = parseVitestJson(json);
+        expect(result?.skipped).toBe(3); // 20 - 15 - 2
+    });
+});
+// ---------------------------------------------------------------------------
+// countTypescriptErrors
+// ---------------------------------------------------------------------------
+describe('countTypescriptErrors', () => {
+    it('counts TypeScript errors in tsc output', () => {
+        const output = [
+            'src/a.ts(1,1): error TS2304: Cannot find name',
+            'src/b.ts(5,3): error TS2345: Argument of type',
+            'src/c.ts(10,1): error TS2322: Type is not assignable',
+        ].join('\n');
+        expect(countTypescriptErrors(output)).toBe(3);
+    });
+    it('returns 0 for clean output', () => {
+        expect(countTypescriptErrors('')).toBe(0);
+        expect(countTypescriptErrors('All good')).toBe(0);
+    });
+    it('handles mixed output with errors and warnings', () => {
+        const output = [
+            'warning TS6059: File not under rootDir',
+            'src/a.ts(1,1): error TS2304: Cannot find name',
+            'Found 1 error.',
+        ].join('\n');
+        expect(countTypescriptErrors(output)).toBe(1); // only counts error TS, not warnings
+    });
+});
+// ---------------------------------------------------------------------------
+// Text output parsing (tested via captureQualityBaseline fallback)
+// ---------------------------------------------------------------------------
+describe('test text output parsing', () => {
+    it('parses vitest text with skipped tests', () => {
+        mockExecSync.mockReturnValueOnce('abc\n');
+        mockExecSync.mockImplementationOnce(() => { throw new Error('no json'); });
+        mockExecSync.mockReturnValueOnce('Tests  10 passed | 2 failed | 1 skipped | 13 total');
+        mockExecSync.mockReturnValueOnce('');
+        const baseline = captureQualityBaseline('/work', {});
+        expect(baseline.tests.total).toBe(13);
+        expect(baseline.tests.passed).toBe(10);
+        expect(baseline.tests.failed).toBe(2);
+        expect(baseline.tests.skipped).toBe(1);
+    });
+    it('parses jest text format', () => {
+        mockExecSync.mockReturnValueOnce('abc\n');
+        mockExecSync.mockImplementationOnce(() => { throw new Error('no json'); });
+        mockExecSync.mockReturnValueOnce('Tests:       2 failed, 42 passed, 44 total');
+        mockExecSync.mockReturnValueOnce('');
+        const baseline = captureQualityBaseline('/work', {});
+        expect(baseline.tests.total).toBe(44);
+        expect(baseline.tests.passed).toBe(42);
+        expect(baseline.tests.failed).toBe(2);
+    });
+    it('parses jest text format with no failures', () => {
+        mockExecSync.mockReturnValueOnce('abc\n');
+        mockExecSync.mockImplementationOnce(() => { throw new Error('no json'); });
+        mockExecSync.mockReturnValueOnce('Tests:       42 passed, 42 total');
+        mockExecSync.mockReturnValueOnce('');
+        const baseline = captureQualityBaseline('/work', {});
+        expect(baseline.tests.total).toBe(42);
+        expect(baseline.tests.passed).toBe(42);
+        expect(baseline.tests.failed).toBe(0);
+    });
+    it('parses vitest compact format "Tests  42 passed (44)"', () => {
+        mockExecSync.mockReturnValueOnce('abc\n');
+        mockExecSync.mockImplementationOnce(() => { throw new Error('no json'); });
+        mockExecSync.mockReturnValueOnce('Tests  42 passed (44)');
+        mockExecSync.mockReturnValueOnce('');
+        const baseline = captureQualityBaseline('/work', {});
+        expect(baseline.tests.total).toBe(44);
+        expect(baseline.tests.passed).toBe(42);
+    });
+    it('parses test counts from error output when command fails', () => {
+        mockExecSync.mockReturnValueOnce('abc\n');
+        mockExecSync.mockImplementationOnce(() => { throw new Error('no json'); });
+        const testError = new Error('tests failed');
+        testError.stdout = 'Tests  8 passed | 2 failed | 10 total';
+        testError.stderr = '';
+        mockExecSync.mockImplementationOnce(() => { throw testError; });
+        mockExecSync.mockReturnValueOnce('');
+        const baseline = captureQualityBaseline('/work', {});
+        expect(baseline.tests.total).toBe(10);
+        expect(baseline.tests.failed).toBe(2);
+    });
+});
+// ---------------------------------------------------------------------------
+// saveBaseline / loadBaseline
+// ---------------------------------------------------------------------------
+describe('saveBaseline', () => {
+    it('writes baseline JSON to .agent/ directory', () => {
+        const baseline = {
+            timestamp: '2026-01-01T00:00:00Z',
+            commitSha: 'abc',
+            tests: { total: 10, passed: 10, failed: 0, skipped: 0 },
+            typecheck: { errorCount: 0, exitCode: 0 },
+            lint: { errorCount: 0, warningCount: 0 },
+        };
+        saveBaseline('/work', baseline);
+        expect(mockWriteFileSync).toHaveBeenCalledWith(expect.stringContaining('quality-baseline.json'), expect.stringContaining('"commitSha": "abc"'));
+    });
+});
+describe('loadBaseline', () => {
+    it('loads baseline from .agent/ directory', () => {
+        const baseline = {
+            timestamp: '2026-01-01T00:00:00Z',
+            commitSha: 'abc',
+            tests: { total: 10, passed: 10, failed: 0, skipped: 0 },
+            typecheck: { errorCount: 0, exitCode: 0 },
+            lint: { errorCount: 0, warningCount: 0 },
+        };
+        mockExistsSync.mockReturnValue(true);
+        mockReadFileSync.mockReturnValue(JSON.stringify(baseline));
+        const loaded = loadBaseline('/work');
+        expect(loaded).toEqual(baseline);
+    });
+    it('returns null when no baseline exists', () => {
+        mockExistsSync.mockReturnValue(false);
+        expect(loadBaseline('/work')).toBeNull();
+    });
+    it('returns null on parse error', () => {
+        mockExistsSync.mockReturnValue(true);
+        mockReadFileSync.mockReturnValue('not json');
+        expect(loadBaseline('/work')).toBeNull();
+    });
+});

package/dist/src/orchestrator/quality-ratchet.d.ts

@@ -0,0 +1,70 @@
+/**
+ * Quality Ratchet — Monotonic Quality Thresholds
+ *
+ * A quality ratchet is a committed JSON file that stores the best-known quality
+ * thresholds for the repository. Thresholds can only tighten (improve), never
+ * loosen. This prevents cumulative quality drift across many agent sessions.
+ *
+ * File location: .agentfactory/quality-ratchet.json (committed to repo)
+ *
+ * The ratchet is enforced at two points:
+ * 1. Merge queue — blocks merge if ratchet thresholds are violated
+ * 2. CI — runs as a required status check on every PR
+ */
+import type { QualityBaseline } from './quality-baseline.js';
+export interface QualityRatchet {
+    version: 1;
+    updatedAt: string;
+    updatedBy: string;
+    thresholds: {
+        testCount: {
+            min: number;
+        };
+        testFailures: {
+            max: number;
+        };
+        typecheckErrors: {
+            max: number;
+        };
+        lintErrors: {
+            max: number;
+        };
+    };
+}
+export interface RatchetCheckResult {
+    passed: boolean;
+    violations: Array<{
+        metric: string;
+        threshold: number;
+        actual: number;
+        direction: 'above-max' | 'below-min';
+    }>;
+}
+/**
+ * Load the quality ratchet from disk.
+ * Returns null if the ratchet file does not exist.
+ * Throws if the file exists but is invalid.
+ */
+export declare function loadQualityRatchet(repoRoot: string): QualityRatchet | null;
+/**
+ * Check current quality metrics against ratchet thresholds.
+ * Returns a result with pass/fail and any violations.
+ */
+export declare function checkQualityRatchet(ratchet: QualityRatchet, current: QualityBaseline): RatchetCheckResult;
+/**
+ * Tighten the quality ratchet if current metrics are better than thresholds.
+ * The ratchet only moves in the direction of improvement (monotonic).
+ *
+ * Returns true if the ratchet was updated, false if no improvement was found.
+ */
+export declare function updateQualityRatchet(repoRoot: string, current: QualityBaseline, identifier: string): boolean;
+/**
+ * Initialize a new quality ratchet file from a baseline snapshot.
+ * Use this when setting up quality gates for the first time.
+ */
+export declare function initializeQualityRatchet(repoRoot: string, baseline: QualityBaseline): QualityRatchet;
+/**
+ * Format a ratchet check result into a human-readable string.
+ */
+export declare function formatRatchetResult(result: RatchetCheckResult): string;
+//# sourceMappingURL=quality-ratchet.d.ts.map

package/dist/src/orchestrator/quality-ratchet.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"quality-ratchet.d.ts","sourceRoot":"","sources":["../../../src/orchestrator/quality-ratchet.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAIH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAA;AAM5D,MAAM,WAAW,cAAc;IAC7B,OAAO,EAAE,CAAC,CAAA;IACV,SAAS,EAAE,MAAM,CAAA;IACjB,SAAS,EAAE,MAAM,CAAA;IACjB,UAAU,EAAE;QACV,SAAS,EAAE;YAAE,GAAG,EAAE,MAAM,CAAA;SAAE,CAAA;QAC1B,YAAY,EAAE;YAAE,GAAG,EAAE,MAAM,CAAA;SAAE,CAAA;QAC7B,eAAe,EAAE;YAAE,GAAG,EAAE,MAAM,CAAA;SAAE,CAAA;QAChC,UAAU,EAAE;YAAE,GAAG,EAAE,MAAM,CAAA;SAAE,CAAA;KAC5B,CAAA;CACF;AAED,MAAM,WAAW,kBAAkB;IACjC,MAAM,EAAE,OAAO,CAAA;IACf,UAAU,EAAE,KAAK,CAAC;QAChB,MAAM,EAAE,MAAM,CAAA;QACd,SAAS,EAAE,MAAM,CAAA;QACjB,MAAM,EAAE,MAAM,CAAA;QACd,SAAS,EAAE,WAAW,GAAG,WAAW,CAAA;KACrC,CAAC,CAAA;CACH;AAiBD;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE,MAAM,GAAG,cAAc,GAAG,IAAI,CAa1E;AAED;;;GAGG;AACH,wBAAgB,mBAAmB,CACjC,OAAO,EAAE,cAAc,EACvB,OAAO,EAAE,eAAe,GACvB,kBAAkB,CA6CpB;AAED;;;;;GAKG;AACH,wBAAgB,oBAAoB,CAClC,QAAQ,EAAE,MAAM,EAChB,OAAO,EAAE,eAAe,EACxB,UAAU,EAAE,MAAM,GACjB,OAAO,CAsCT;AAED;;;GAGG;AACH,wBAAgB,wBAAwB,CACtC,QAAQ,EAAE,MAAM,EAChB,QAAQ,EAAE,eAAe,GACxB,cAAc,CAehB;AAED;;GAEG;AACH,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,kBAAkB,GAAG,MAAM,CAYtE"}

package/dist/src/orchestrator/quality-ratchet.js

@@ -0,0 +1,162 @@
+/**
+ * Quality Ratchet — Monotonic Quality Thresholds
+ *
+ * A quality ratchet is a committed JSON file that stores the best-known quality
+ * thresholds for the repository. Thresholds can only tighten (improve), never
+ * loosen. This prevents cumulative quality drift across many agent sessions.
+ *
+ * File location: .agentfactory/quality-ratchet.json (committed to repo)
+ *
+ * The ratchet is enforced at two points:
+ * 1. Merge queue — blocks merge if ratchet thresholds are violated
+ * 2. CI — runs as a required status check on every PR
+ */
+import { readFileSync, writeFileSync, existsSync } from 'node:fs';
+import { resolve } from 'node:path';
+// ---------------------------------------------------------------------------
+// File path
+// ---------------------------------------------------------------------------
+const RATCHET_FILENAME = 'quality-ratchet.json';
+const RATCHET_DIR = '.agentfactory';
+function ratchetPath(repoRoot) {
+    return resolve(repoRoot, RATCHET_DIR, RATCHET_FILENAME);
+}
+// ---------------------------------------------------------------------------
+// Public API
+// ---------------------------------------------------------------------------
+/**
+ * Load the quality ratchet from disk.
+ * Returns null if the ratchet file does not exist.
+ * Throws if the file exists but is invalid.
+ */
+export function loadQualityRatchet(repoRoot) {
+    const filePath = ratchetPath(repoRoot);
+    if (!existsSync(filePath))
+        return null;
+    const content = readFileSync(filePath, 'utf-8');
+    const parsed = JSON.parse(content);
+    // Basic validation
+    if (parsed.version !== 1 || !parsed.thresholds) {
+        throw new Error(`Invalid quality ratchet file: missing version or thresholds`);
+    }
+    return parsed;
+}
+/**
+ * Check current quality metrics against ratchet thresholds.
+ * Returns a result with pass/fail and any violations.
+ */
+export function checkQualityRatchet(ratchet, current) {
+    const violations = [];
+    const { thresholds } = ratchet;
+    if (current.tests.total < thresholds.testCount.min) {
+        violations.push({
+            metric: 'testCount',
+            threshold: thresholds.testCount.min,
+            actual: current.tests.total,
+            direction: 'below-min',
+        });
+    }
+    if (current.tests.failed > thresholds.testFailures.max) {
+        violations.push({
+            metric: 'testFailures',
+            threshold: thresholds.testFailures.max,
+            actual: current.tests.failed,
+            direction: 'above-max',
+        });
+    }
+    if (current.typecheck.errorCount > thresholds.typecheckErrors.max) {
+        violations.push({
+            metric: 'typecheckErrors',
+            threshold: thresholds.typecheckErrors.max,
+            actual: current.typecheck.errorCount,
+            direction: 'above-max',
+        });
+    }
+    if (current.lint.errorCount > thresholds.lintErrors.max) {
+        violations.push({
+            metric: 'lintErrors',
+            threshold: thresholds.lintErrors.max,
+            actual: current.lint.errorCount,
+            direction: 'above-max',
+        });
+    }
+    return {
+        passed: violations.length === 0,
+        violations,
+    };
+}
+/**
+ * Tighten the quality ratchet if current metrics are better than thresholds.
+ * The ratchet only moves in the direction of improvement (monotonic).
+ *
+ * Returns true if the ratchet was updated, false if no improvement was found.
+ */
+export function updateQualityRatchet(repoRoot, current, identifier) {
+    const existing = loadQualityRatchet(repoRoot);
+    if (!existing)
+        return false;
+    const updated = { ...existing, thresholds: { ...existing.thresholds } };
+    let changed = false;
+    // Test count: min can only go up
+    if (current.tests.total > existing.thresholds.testCount.min) {
+        updated.thresholds.testCount = { min: current.tests.total };
+        changed = true;
+    }
+    // Test failures: max can only go down
+    if (current.tests.failed < existing.thresholds.testFailures.max) {
+        updated.thresholds.testFailures = { max: current.tests.failed };
+        changed = true;
+    }
+    // Typecheck errors: max can only go down
+    if (current.typecheck.errorCount < existing.thresholds.typecheckErrors.max) {
+        updated.thresholds.typecheckErrors = { max: current.typecheck.errorCount };
+        changed = true;
+    }
+    // Lint errors: max can only go down
+    if (current.lint.errorCount < existing.thresholds.lintErrors.max) {
+        updated.thresholds.lintErrors = { max: current.lint.errorCount };
+        changed = true;
+    }
+    if (changed) {
+        updated.updatedAt = new Date().toISOString();
+        updated.updatedBy = identifier;
+        writeFileSync(ratchetPath(repoRoot), JSON.stringify(updated, null, 2) + '\n');
+    }
+    return changed;
+}
+/**
+ * Initialize a new quality ratchet file from a baseline snapshot.
+ * Use this when setting up quality gates for the first time.
+ */
+export function initializeQualityRatchet(repoRoot, baseline) {
+    const ratchet = {
+        version: 1,
+        updatedAt: new Date().toISOString(),
+        updatedBy: 'manual',
+        thresholds: {
+            testCount: { min: baseline.tests.total },
+            testFailures: { max: baseline.tests.failed },
+            typecheckErrors: { max: baseline.typecheck.errorCount },
+            lintErrors: { max: baseline.lint.errorCount },
+        },
+    };
+    writeFileSync(ratchetPath(repoRoot), JSON.stringify(ratchet, null, 2) + '\n');
+    return ratchet;
+}
+/**
+ * Format a ratchet check result into a human-readable string.
+ */
+export function formatRatchetResult(result) {
+    if (result.passed)
+        return 'Quality ratchet check passed.';
+    const lines = ['Quality ratchet check **FAILED**:', ''];
+    for (const v of result.violations) {
+        if (v.direction === 'above-max') {
+            lines.push(`- ${v.metric}: ${v.actual} exceeds maximum threshold of ${v.threshold}`);
+        }
+        else {
+            lines.push(`- ${v.metric}: ${v.actual} is below minimum threshold of ${v.threshold}`);
+        }
+    }
+    return lines.join('\n');
+}