swarm-orchestrator 7.0.0-alpha.0

package/dist/src/verification/property-gate.js

@@ -0,0 +1,201 @@
+"use strict";
+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 });
+exports.discoverPropertyTargets = discoverPropertyTargets;
+exports.runPropertyGate = runPropertyGate;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const command_runner_1 = require("./command-runner");
+function isSupportedFile(filePath) {
+    return /\.(?:ts|tsx|js|jsx|py)$/.test(filePath) && !filePath.endsWith('.d.ts');
+}
+function safeName(value) {
+    return value.replace(/[^a-zA-Z0-9._-]/g, '-');
+}
+function isTypedTypeScriptSignature(params, suffix) {
+    return /:\s*[\w.[\]<>|]+/.test(params) || /^\s*:\s*[\w.[\]<>|]+/.test(suffix);
+}
+function isTypedPythonSignature(params, suffix) {
+    return /:\s*[\w.[\]<>|]+/.test(params) || /->\s*[\w.[\]<>|]+/.test(suffix);
+}
+function discoverInSource(filePath, source) {
+    const ext = path.extname(filePath);
+    const targets = [];
+    if (ext === '.py') {
+        for (const match of source.matchAll(/(?:^|\n)def\s+([A-Za-z_]\w*)\s*\(([^)]*)\)\s*([^:]*):/g)) {
+            const typed = isTypedPythonSignature(match[2] ?? '', match[3] ?? '');
+            targets.push({
+                language: 'python',
+                filePath,
+                functionName: match[1] ?? 'unknown',
+                typed,
+                advisoryOnly: !typed,
+            });
+        }
+        return targets;
+    }
+    const language = ext === '.ts' || ext === '.tsx' ? 'typescript' : 'javascript';
+    const patterns = [
+        /(?:export\s+)?function\s+([A-Za-z_]\w*)\s*\(([^)]*)\)\s*([^ {=>]*)/g,
+        /(?:export\s+)?const\s+([A-Za-z_]\w*)\s*=\s*\(([^)]*)\)\s*([^=]*)=>/g,
+    ];
+    for (const pattern of patterns) {
+        for (const match of source.matchAll(pattern)) {
+            const typed = language === 'typescript'
+                ? isTypedTypeScriptSignature(match[2] ?? '', match[3] ?? '')
+                : false;
+            targets.push({
+                language,
+                filePath,
+                functionName: match[1] ?? 'unknown',
+                typed,
+                advisoryOnly: language === 'javascript' || !typed,
+            });
+        }
+    }
+    return targets;
+}
+/**
+ * Discover modified functions that can receive generated property tests.
+ *
+ * @param repoPath - Target repository root.
+ * @param changedFiles - Repo-relative changed file paths.
+ * @returns Function targets with type-system coverage metadata.
+ */
+function discoverPropertyTargets(repoPath, changedFiles) {
+    const targets = [];
+    for (const rel of changedFiles.filter(isSupportedFile)) {
+        if (rel.startsWith('/') || path.normalize(rel).startsWith('..'))
+            continue;
+        const full = path.join(repoPath, rel);
+        if (!fs.existsSync(full) || !fs.statSync(full).isFile())
+            continue;
+        targets.push(...discoverInSource(rel, fs.readFileSync(full, 'utf8')));
+    }
+    return targets;
+}
+function jsHarness(target, importRel) {
+    const importPath = importRel.startsWith('.') ? importRel : './' + importRel;
+    return [
+        "const fc = require('fast-check');",
+        `const mod = require('${importPath}');`,
+        `const fn = mod.${target.functionName};`,
+        "if (typeof fn !== 'function') throw new Error('target function is not exported');",
+        'fc.assert(fc.property(fc.anything(), fc.anything(), (a, b) => {',
+        '  try { fn(a, b); return true; }',
+        "  catch (err) { throw new Error('Counterexample: ' + JSON.stringify([a, b]) + ' -> ' + err.message); }",
+        '}), { numRuns: 100 });',
+        '',
+    ].join('\n');
+}
+function pythonHarness(target, moduleName) {
+    return [
+        'from hypothesis import given, strategies as st',
+        `from ${moduleName} import ${target.functionName}`,
+        '',
+        '@given(st.integers(), st.integers())',
+        'def test_generated_property(a, b):',
+        `    ${target.functionName}(a, b)`,
+        '',
+        'if __name__ == "__main__":',
+        '    test_generated_property()',
+        '',
+    ].join('\n');
+}
+function pythonModuleName(filePath) {
+    return filePath.replace(/\.py$/, '').replace(/[\\/]/g, '.').replace(/^\.+/, '');
+}
+function buildPropertyCommand(repoPath, target) {
+    const outDir = path.join(repoPath, '.swarm', 'property-tests');
+    fs.mkdirSync(outDir, { recursive: true });
+    const base = `${safeName(target.filePath)}-${safeName(target.functionName)}`;
+    if (target.language === 'python') {
+        const harness = path.join(outDir, `${base}.py`);
+        fs.writeFileSync(harness, pythonHarness(target, pythonModuleName(target.filePath)), 'utf8');
+        return `python ${path.relative(repoPath, harness)}`;
+    }
+    const extension = target.language === 'typescript' ? '.ts' : '.js';
+    const harness = path.join(outDir, `${base}${extension}`);
+    const targetPath = path.join(repoPath, target.filePath);
+    const importRel = path.relative(path.dirname(harness), targetPath).replace(/\\/g, '/');
+    fs.writeFileSync(harness, jsHarness(target, importRel), 'utf8');
+    return target.language === 'typescript'
+        ? `npx tsx ${path.relative(repoPath, harness)}`
+        : `node ${path.relative(repoPath, harness)}`;
+}
+function extractCounterexample(output) {
+    const match = output.match(/Counterexample:\s*([^\n]+)/i);
+    return match?.[1]?.trim();
+}
+/**
+ * Run generated property-based tests for modified functions.
+ *
+ * Untyped JavaScript is intentionally advisory-only because generators cannot
+ * be type-directed; the gate still fuzzes with generic values and reports a
+ * reduced-confidence finding when a counterexample appears.
+ *
+ * @param input - Target repo, changed files, timeout, and optional runner.
+ * @returns Advisory property-testing result.
+ */
+async function runPropertyGate(input) {
+    const targets = discoverPropertyTargets(input.targetRepoPath, input.changedFiles);
+    if (targets.length === 0) {
+        return { status: 'SKIP', score: 1, targets: [], findings: [] };
+    }
+    const runner = input.commandRunner ?? command_runner_1.runVerificationCommand;
+    const findings = [];
+    for (const target of targets) {
+        const command = buildPropertyCommand(input.targetRepoPath, target);
+        const result = await runner(command, input.targetRepoPath, input.timeoutMsPerFunction ?? 60_000);
+        if (result.exitCode !== 0) {
+            const output = `${result.stdout}\n${result.stderr}`;
+            const counterexample = extractCounterexample(output);
+            findings.push({
+                filePath: target.filePath,
+                functionName: target.functionName,
+                ...(counterexample ? { counterexample } : {}),
+                explanation: target.advisoryOnly
+                    ? 'generic advisory fuzzing found a failure or the property tool could not run'
+                    : 'property-based test found a counterexample or tool failure',
+            });
+        }
+    }
+    return {
+        status: findings.length > 0 ? 'ADVISORY' : 'PASS',
+        score: Math.max(0, Number((1 - findings.length * 0.25).toFixed(3))),
+        targets,
+        findings,
+    };
+}

package/dist/src/verification/test-synthesizer.js

@@ -0,0 +1,243 @@
+"use strict";
+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 });
+exports.validateSynthesizedTestCandidate = validateSynthesizedTestCandidate;
+exports.synthesizeRegressionTest = synthesizeRegressionTest;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const claude_code_adapter_1 = require("../adapters/claude-code-adapter");
+const command_runner_1 = require("./command-runner");
+const DEFAULT_MODEL = 'claude-sonnet-4.6';
+const SYNTH_TEST_DIR = '.swarm/synthesized-tests';
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function extractJsonObject(text) {
+    const fenced = text.match(/```(?:json)?\s*(\{[\s\S]*?\})\s*```/);
+    const raw = fenced?.[1] ?? text.slice(text.indexOf('{'), text.lastIndexOf('}') + 1);
+    if (!raw || raw.trim() === '') {
+        throw new Error('adapter output did not contain a JSON object');
+    }
+    return JSON.parse(raw);
+}
+function parseCandidate(stdout) {
+    const parsed = extractJsonObject(stdout);
+    if (!isRecord(parsed)) {
+        throw new Error('candidate JSON must be an object');
+    }
+    const testFilePath = parsed.testFilePath;
+    const testCommand = parsed.testCommand;
+    const testSource = parsed.testSource;
+    if (typeof testCommand !== 'string' || testCommand.trim() === '') {
+        throw new Error('candidate JSON must include non-empty testCommand');
+    }
+    if (typeof testSource !== 'string' || testSource.trim() === '') {
+        throw new Error('candidate JSON must include non-empty testSource');
+    }
+    return {
+        testFilePath: typeof testFilePath === 'string' && testFilePath.trim() !== ''
+            ? testFilePath
+            : 'synthesized-regression.test.js',
+        testCommand,
+        testSource,
+    };
+}
+/**
+ * Validate that a generated test has meaningful assertions.
+ *
+ * @param candidate - Generated test candidate.
+ * @returns Rejection reason, or undefined when the test is structurally usable.
+ */
+function validateSynthesizedTestCandidate(candidate) {
+    const source = candidate.testSource;
+    const assertionPatterns = [
+        /\bassert\.(?:strictEqual|deepStrictEqual|notStrictEqual|throws|rejects|ok)\s*\(/,
+        /\bexpect\s*\(/,
+        /\bshould\b/,
+    ];
+    const weakPatterns = [
+        /\bassert\.ok\s*\(\s*true\s*\)/,
+        /\bexpect\s*\(\s*true\s*\)/,
+    ];
+    if (!assertionPatterns.some(pattern => pattern.test(source))) {
+        return 'generated test has no clear assertion or explicit failure mode';
+    }
+    if (weakPatterns.some(pattern => pattern.test(source))) {
+        return 'generated test only asserts an unconditional truth';
+    }
+    return undefined;
+}
+function safeOutputPath(repoPath, candidatePath, attemptNumber) {
+    const safeName = path.basename(candidatePath).replace(/[^a-zA-Z0-9._-]/g, '-')
+        || 'synthesized-regression.test.js';
+    return path.join(repoPath, SYNTH_TEST_DIR, `attempt-${attemptNumber}-${safeName}`);
+}
+function writeCandidate(repoPath, candidate, attemptNumber) {
+    const absolutePath = safeOutputPath(repoPath, candidate.testFilePath, attemptNumber);
+    fs.mkdirSync(path.dirname(absolutePath), { recursive: true });
+    fs.writeFileSync(absolutePath, candidate.testSource, 'utf8');
+    const relativePath = path.relative(repoPath, absolutePath);
+    const command = candidate.testCommand.includes('{{TEST_FILE}}')
+        ? candidate.testCommand.replace(/\{\{TEST_FILE\}\}/g, relativePath)
+        : candidate.testCommand.replace(candidate.testFilePath, relativePath);
+    return { absolutePath, relativePath, command };
+}
+function readRelevantFiles(repoPath, relevantFiles) {
+    if (!relevantFiles || relevantFiles.length === 0)
+        return 'No relevant files were supplied.';
+    const sections = [];
+    for (const rel of relevantFiles.slice(0, 8)) {
+        if (rel.startsWith('/') || path.normalize(rel).startsWith('..'))
+            continue;
+        const full = path.join(repoPath, rel);
+        if (!fs.existsSync(full) || !fs.statSync(full).isFile())
+            continue;
+        const body = fs.readFileSync(full, 'utf8').slice(0, 4_000);
+        sections.push(`FILE: ${rel}\n\`\`\`\n${body}\n\`\`\``);
+    }
+    return sections.length > 0 ? sections.join('\n\n') : 'No readable relevant files were found.';
+}
+function buildPrompt(input, feedback) {
+    return `Generate one regression test for this goal:
+
+${input.goalText}
+
+Relevant source context:
+${readRelevantFiles(input.targetRepoPath, input.relevantFiles)}
+
+Return ONLY JSON with this schema:
+{
+  "testFilePath": "relative/path/to/regression.test.js",
+  "testCommand": "command that runs only this test; use {{TEST_FILE}} for the generated file path",
+  "testSource": "complete test source"
+}
+
+The test must contain clear assertions, fail against the current codebase, and pass once the goal is correctly implemented.
+${feedback ? `Previous attempt feedback: ${feedback}` : ''}`;
+}
+/**
+ * Generate a user-goal regression test and prove it fails against the base repo.
+ *
+ * @param input - Goal, repo path, adapter, and retry settings.
+ * @returns Synthesized test path and command, or an ambiguous/failed status.
+ */
+async function synthesizeRegressionTest(input) {
+    const adapter = input.adapter ?? new claude_code_adapter_1.ClaudeCodeAdapter();
+    const maxAttempts = input.maxAttempts ?? 3;
+    const timeoutMs = input.timeoutMs ?? 120_000;
+    const attempts = [];
+    let feedback;
+    for (let attemptNumber = 1; attemptNumber <= maxAttempts; attemptNumber += 1) {
+        const adapterResult = await adapter.spawn({
+            prompt: buildPrompt(input, feedback),
+            workdir: input.targetRepoPath,
+            model: input.model ?? DEFAULT_MODEL,
+            timeout: timeoutMs,
+        });
+        if (adapterResult.exitCode !== 0) {
+            feedback = adapterResult.stderr || 'adapter exited non-zero';
+            attempts.push({
+                attemptNumber,
+                adapterExitCode: adapterResult.exitCode,
+                validation: 'rejected',
+                rejectionReason: feedback,
+            });
+            continue;
+        }
+        let candidate;
+        try {
+            candidate = parseCandidate(adapterResult.stdout);
+        }
+        catch (err) {
+            feedback = err instanceof Error ? err.message : String(err);
+            attempts.push({
+                attemptNumber,
+                adapterExitCode: adapterResult.exitCode,
+                validation: 'rejected',
+                rejectionReason: feedback,
+            });
+            continue;
+        }
+        const structuralRejection = validateSynthesizedTestCandidate(candidate);
+        if (structuralRejection) {
+            feedback = structuralRejection;
+            attempts.push({
+                attemptNumber,
+                adapterExitCode: adapterResult.exitCode,
+                validation: 'rejected',
+                rejectionReason: structuralRejection,
+                candidate,
+            });
+            continue;
+        }
+        const written = writeCandidate(input.targetRepoPath, candidate, attemptNumber);
+        const commandResult = await (0, command_runner_1.runVerificationCommand)(written.command, input.targetRepoPath, timeoutMs);
+        if (commandResult.exitCode !== 0) {
+            const accepted = {
+                ...candidate,
+                testFilePath: written.absolutePath,
+                testCommand: written.command,
+            };
+            attempts.push({
+                attemptNumber,
+                adapterExitCode: adapterResult.exitCode,
+                validation: 'accepted',
+                candidate: accepted,
+                commandResult,
+            });
+            return {
+                status: 'GENERATED',
+                reason: 'generated test fails against the base codebase',
+                attempts,
+                testFilePath: written.absolutePath,
+                testCommand: written.command,
+            };
+        }
+        feedback = 'generated test passed against the base codebase; make it expose the bug or missing behavior';
+        attempts.push({
+            attemptNumber,
+            adapterExitCode: adapterResult.exitCode,
+            validation: 'rejected',
+            rejectionReason: feedback,
+            candidate,
+            commandResult,
+        });
+    }
+    return {
+        status: attempts.some(attempt => attempt.adapterExitCode === 0) ? 'AMBIGUOUS_GOAL' : 'GENERATION_FAILED',
+        reason: feedback ?? 'test synthesizer could not produce a failing regression test',
+        attempts,
+    };
+}