@skyramp/mcp 0.3.2-rc.pom-4 → 0.3.2

package/build/tools/code-refactor/reuse-state.js

@@ -0,0 +1,140 @@
+import * as path from "path";
+import { readFile } from "fs/promises";
+import { logger } from "../../utils/logger.js";
+import { resolveRunStatePath, StateManager, } from "../../utils/AnalysisStateManager.js";
+import { verifyReuse } from "../../utils/pom-verify/index.js";
+import { buildSkipped, findUnparsableKeptInline, flaggedFrom, mergeFlagged, verificationFrom, ReuseVerificationOutcome, } from "./reuse-outcome.js";
+/**
+ * Persistence for the server-derived POM-reuse outcome, keyed by test-file
+ * basename (what `newTestsCreated[].fileName` carries, so
+ * `skyramp_submit_report` can match without path normalization).
+ *
+ * Every write is best-effort. Reuse observability must never be able to fail a
+ * refactor that otherwise succeeded, so a missing/unreadable/unwritable state
+ * file degrades to "no reuse summary in the report" — the same outcome as running
+ * outside a Testbot run, where there is no run state to record into.
+ */
+/**
+ * Read-modify-write one spec's outcome. `patch` receives the entry recorded so
+ * far, so a caller that needs prior state (the verify pass, which accumulates
+ * flagged members) uses the same path as one that does not.
+ *
+ * Fields the patch omits are preserved: the prompt-generation call knows the
+ * candidate count, each verify pass knows the counts and verdict.
+ */
+async function updateReuseOutcome(testFile, patch, explicitStateFile) {
+    const stateFile = resolveRunStatePath(explicitStateFile);
+    if (!stateFile)
+        return;
+    try {
+        const manager = StateManager.fromStatePath(stateFile);
+        const data = await manager.readData();
+        if (!data)
+            return;
+        const key = path.basename(testFile);
+        const existing = data.reuseOutcomes?.[key] ?? {};
+        await manager.writeData({
+            ...data,
+            reuseOutcomes: { ...data.reuseOutcomes, [key]: { ...existing, ...patch(existing) } },
+        });
+    }
+    catch (err) {
+        logger.warning("Could not record POM-reuse outcome — report will omit the reuse summary", {
+            testFile,
+            error: String(err),
+        });
+    }
+}
+/** Record the tier-1 candidate count STEP 1 detected. */
+export async function recordCandidates(testFile, candidatesDetected, explicitStateFile) {
+    await updateReuseOutcome(testFile, () => ({ candidatesDetected }), explicitStateFile);
+}
+/** The prompt-generation call found no reusable POM layer at all. No candidate
+ *  count is recorded: "0 candidates" adds nothing to "no POM layer was found",
+ *  and rendering both produces a redundant zero in the summary. */
+export async function recordNoPomLayer(testFile, explicitStateFile) {
+    await updateReuseOutcome(testFile, () => ({ verification: ReuseVerificationOutcome.SkippedNoPom }), explicitStateFile);
+}
+/**
+ * Record what one verify pass established: the call counts, the verdict, and the
+ * declines read out of the spec the verifier just parsed.
+ *
+ * `flagged` accumulates across passes because a PASSED verdict has no violations
+ * left to inspect — a member that was substituted and then restored survives only
+ * as a `// kept inline:` comment, indistinguishable from one the mapper never
+ * promoted. Accumulating is what keeps that distinction recoverable at all; it does
+ * not by itself establish it, since a flagged member may have been remapped rather
+ * than restored (see buildSkipped for how narrowly it is trusted).
+ */
+export async function recordVerifyOutcome(testFile, r, gateFired, language, explicitStateFile) {
+    if (!resolveRunStatePath(explicitStateFile))
+        return;
+    await updateReuseOutcome(testFile, (existing) => {
+        const flagged = mergeFlagged(existing.flagged, flaggedFrom(r));
+        return {
+            testFilePath: testFile,
+            language,
+            verification: verificationFrom(gateFired, r),
+            ...(flagged.length > 0 ? { flagged } : {}),
+        };
+    }, explicitStateFile);
+}
+/**
+ * Re-derive a recorded outcome from the spec as it stands NOW, so the report
+ * describes the delivered artifact rather than the state at verify time.
+ *
+ * The two can differ: the execution fix-up may restore `<testFile>.raw.bak` over
+ * the spec after verification, reverting every substitution with a plain `cp` that
+ * this tool never sees. Trusting the recorded counts there would publish
+ * `callsReused: 5, verification: "passed"` for a spec containing no POM calls —
+ * a confident false claim, strictly worse than the silence this feature replaced.
+ * Re-deriving here rather than requiring a final `verify: true` pass is deliberate:
+ * the report step always runs, so the agent cannot skip it.
+ *
+ * `candidatesDetected` is kept as recorded — it counts POM FILES that detection
+ * found, which a restore does not change. Everything else comes from the file.
+ *
+ * `verification` is dropped when the delivered spec reuses nothing: a PASSED
+ * verdict describes a spec that no longer exists, and pairing it with a zero count
+ * reads as though the empty result had been blessed.
+ *
+ * Returns the recorded outcome minus internals when re-derivation is impossible
+ * (no path recorded — e.g. only the candidate count was ever written), and
+ * `undefined` when it fails outright. Failing closed matters: falling back to the
+ * recorded counts is exactly the false claim this exists to prevent.
+ */
+export async function rederiveReuseOutcome(record) {
+    const { candidatesDetected, verification, flagged, testFilePath, language } = record;
+    // No verify pass ran for this spec, so there are no counts to derive — only the
+    // detection-time facts, which no spec change can invalidate.
+    if (!testFilePath || !language)
+        return { candidatesDetected, verification };
+    try {
+        const r = await verifyReuse(testFilePath, language);
+        const specContent = await readFile(testFilePath, "utf8");
+        // Diagnose the file the report is actually built from. A marker the zero-reuse
+        // gate accepts but this cannot parse satisfies the escape hatch while its
+        // decline never reaches the report — silent signal loss is the failure class
+        // this feature exists to close.
+        const unparsable = findUnparsableKeptInline(specContent);
+        if (unparsable.length > 0) {
+            logger.warning("Malformed `// kept inline:` marker(s) in the delivered spec — these declines will be missing from the PR report. " +
+                "Use `// kept inline: <file basename> — <reason>` (em dash, or a hyphen with spaces around it).", { testFile: testFilePath, markers: unparsable });
+        }
+        const skipped = buildSkipped(specContent, flagged);
+        return {
+            candidatesDetected,
+            callsReused: r.reusedCalls,
+            callsVerified: r.checkedCalls,
+            // A PASSED verdict describes a spec that no longer exists once reuse is gone,
+            // and pairing it with a zero count reads as though the empty result had been
+            // blessed.
+            verification: r.reusedCalls > 0 ? verification : undefined,
+            skipped: skipped.length > 0 ? skipped : undefined,
+        };
+    }
+    catch (err) {
+        logger.warning("Could not re-derive the POM-reuse outcome from the delivered spec — omitting the reuse summary rather than reporting counts that may no longer hold", { testFile: testFilePath, error: String(err) });
+        return undefined;
+    }
+}

package/build/tools/enrichTestWithMocksTool.d.ts

@@ -0,0 +1,28 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { ProgrammingLanguage, MockProtocol } from "../types/TestTypes.js";
+/**
+ * skyramp_enrich_test_with_mocks
+ *
+ * Injects mock imports and apply_mock() calls into a generated test file.
+ * The mock files are generated by skyramp_mock_generation — this tool wires
+ * them into the test so the mocks are applied before the test runs.
+ *
+ * No data duplication — the test imports from the generated mock files.
+ */
+export declare function registerEnrichTestWithMocksTool(server: McpServer): void;
+declare function injectMockImports(original: string, testFile: string, scenarioName: string, mockFiles: string[], traceComments?: string[], language?: ProgrammingLanguage): string;
+declare function isSupportedMockEnrichmentLanguage(language: ProgrammingLanguage | string): language is ProgrammingLanguage;
+type MockEntry = {
+    serviceName: string;
+    moduleName: string;
+    relativePath: string;
+    importPath: string;
+    importLabel: string;
+    mockFile: string;
+    className: string;
+    classReference: string;
+    targetUrl?: string;
+    protocol: MockProtocol;
+};
+declare function buildMockImportBlock(testFile: string, scenarioName: string, mockFiles: string[], traceComments?: string[], language?: ProgrammingLanguage, mockEntries?: MockEntry[]): string;
+export { injectMockImports, buildMockImportBlock, isSupportedMockEnrichmentLanguage };