@sweny-ai/core 0.1.77 → 0.1.78

package/dist/__tests__/requires.test.js

@@ -1,82 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { evaluateRequires } from "../requires.js";
-describe("evaluateRequires", () => {
-    it("returns null when requires is undefined", () => {
-        expect(evaluateRequires(undefined, { input: {} })).toBeNull();
-    });
-    it("returns null when all checks pass", () => {
-        const requires = {
-            output_required: ["input.repoUrl"],
-            output_matches: [{ path: "triage.recommendation", equals: "implement" }],
-        };
-        const ctx = {
-            input: { repoUrl: "https://x" },
-            triage: { recommendation: "implement" },
-        };
-        expect(evaluateRequires(requires, ctx)).toBeNull();
-    });
-    it("reports missing input field", () => {
-        const requires = { output_required: ["input.repoUrl"] };
-        const err = evaluateRequires(requires, { input: {} });
-        expect(err).not.toBeNull();
-        expect(err).toMatch(/^requires failed:/);
-        expect(err).toMatch(/'input\.repoUrl'/);
-    });
-    it("reports missing prior node output", () => {
-        const requires = { output_required: ["triage.recommendation"] };
-        const err = evaluateRequires(requires, { input: {} });
-        expect(err).not.toBeNull();
-        expect(err).toMatch(/'triage\.recommendation'/);
-    });
-    it("reports null upstream value as missing", () => {
-        const requires = { output_required: ["triage.recommendation"] };
-        const err = evaluateRequires(requires, {
-            input: {},
-            triage: { recommendation: null },
-        });
-        expect(err).toMatch(/null/);
-    });
-    it("supports `any:` wildcard semantics on requires paths", () => {
-        const requires = {
-            output_required: ["any:scan.findings[*].severity"],
-        };
-        const ctx = { input: {}, scan: { findings: [{ severity: "low" }, { severity: "high" }] } };
-        expect(evaluateRequires(requires, ctx)).toBeNull();
-    });
-    it("reports output_matches failure with operator description", () => {
-        const requires = {
-            output_matches: [{ path: "triage.recommendation", equals: "implement" }],
-        };
-        const err = evaluateRequires(requires, {
-            input: {},
-            triage: { recommendation: "skip" },
-        });
-        expect(err).toMatch(/equals "implement"/);
-        expect(err).toMatch(/got \["skip"\]/);
-    });
-    it("aggregates multiple failures into one string", () => {
-        const requires = {
-            output_required: ["input.a", "input.b"],
-            output_matches: [{ path: "input.c", equals: 1 }],
-        };
-        const err = evaluateRequires(requires, { input: { c: 2 } });
-        expect(err).toMatch(/'input\.a'/);
-        expect(err).toMatch(/'input\.b'/);
-        expect(err).toMatch(/'input\.c'/);
-    });
-    it("does not crash when context map is empty", () => {
-        const requires = { output_required: ["input.x"] };
-        const err = evaluateRequires(requires, {});
-        expect(err).not.toBeNull();
-    });
-    // ── Test 10: malformed block with no checks declared (fix B) ──
-    it("returns failure when requires block has no checks declared (fix B defensive guard)", () => {
-        // Post-merge fix B: evaluateRequires fails loudly when a requires block
-        // exists but declares neither output_required nor output_matches.
-        // Passing on_fail directly to bypass TypeScript's NodeRequires type.
-        const err = evaluateRequires({ on_fail: "fail" }, { input: {} });
-        expect(err).not.toBeNull();
-        expect(err).toMatch(/^requires failed:/);
-        expect(err).toMatch(/no checks declared/);
-    });
-});

package/dist/__tests__/retry.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/__tests__/retry.test.js

@@ -1,213 +0,0 @@
-import { describe, expect, it, vi } from "vitest";
-import { buildRetryPreamble } from "../retry.js";
-const tc = (tool, output) => ({ tool, input: {}, output });
-const silentLogger = {
-    info: () => { },
-    warn: () => { },
-    error: () => { },
-    debug: () => { },
-};
-function fakeClaude(askResult) {
-    return {
-        run: async () => ({ status: "success", data: {}, toolCalls: [] }),
-        evaluate: async () => "x",
-        ask: vi.fn(async () => {
-            if (typeof askResult === "function")
-                return askResult();
-            return askResult;
-        }),
-    };
-}
-describe("buildRetryPreamble", () => {
-    const verifyError = "verify failed:\n  - any_tool_called: required one of [foo]";
-    const nodeInstruction = "Open a PR with the fix";
-    it("uses default preamble when no instruction is provided", async () => {
-        const claude = fakeClaude("");
-        const result = await buildRetryPreamble({
-            retry: { max: 1 },
-            verifyError,
-            context: {},
-            toolCalls: [],
-            nodeInstruction,
-            claude,
-            logger: silentLogger,
-        });
-        expect(result).toMatch(/Previous attempt failed verification/);
-        expect(result).toContain(verifyError);
-        expect(claude.ask).not.toHaveBeenCalled();
-    });
-    it("uses static string preamble when instruction is a string", async () => {
-        const claude = fakeClaude("");
-        const result = await buildRetryPreamble({
-            retry: { max: 1, instruction: "Remember to call linear_create_issue first." },
-            verifyError,
-            context: {},
-            toolCalls: [],
-            nodeInstruction,
-            claude,
-            logger: silentLogger,
-        });
-        expect(result).toContain("Remember to call linear_create_issue first.");
-        expect(result).toContain(verifyError);
-        expect(claude.ask).not.toHaveBeenCalled();
-    });
-    it("calls claude.ask with default reflection prompt when instruction.auto is true", async () => {
-        const claude = fakeClaude("Diagnosis: you forgot to call foo. Strategy: call foo first.");
-        const askSpy = claude.ask;
-        const result = await buildRetryPreamble({
-            retry: { max: 1, instruction: { auto: true } },
-            verifyError,
-            context: {},
-            toolCalls: [tc("bar", { ok: true })],
-            nodeInstruction,
-            claude,
-            logger: silentLogger,
-        });
-        expect(askSpy).toHaveBeenCalledOnce();
-        const callArg = askSpy.mock.calls[0][0];
-        expect(callArg.instruction).toMatch(/Briefly diagnose the failure/);
-        expect(callArg.instruction).toContain(nodeInstruction);
-        expect(callArg.instruction).toContain(verifyError);
-        expect(callArg.instruction).toContain("bar");
-        expect(result).toContain("Diagnosis: you forgot to call foo");
-        expect(result).toContain(verifyError);
-    });
-    it("calls claude.ask with author prompt when instruction.reflect is set", async () => {
-        const claude = fakeClaude("Custom diagnosis.");
-        const askSpy = claude.ask;
-        await buildRetryPreamble({
-            retry: { max: 1, instruction: { reflect: "Focus on the missing tool calls only." } },
-            verifyError,
-            context: {},
-            toolCalls: [],
-            nodeInstruction,
-            claude,
-            logger: silentLogger,
-        });
-        const callArg = askSpy.mock.calls[0][0];
-        expect(callArg.instruction).toContain("Focus on the missing tool calls only.");
-        expect(callArg.instruction).toContain(verifyError);
-    });
-    it("falls back to default preamble when claude.ask throws", async () => {
-        const claude = fakeClaude(() => {
-            throw new Error("network exploded");
-        });
-        const warnSpy = vi.fn();
-        const logger = { ...silentLogger, warn: warnSpy };
-        const result = await buildRetryPreamble({
-            retry: { max: 1, instruction: { auto: true } },
-            verifyError,
-            context: {},
-            toolCalls: [],
-            nodeInstruction,
-            claude,
-            logger,
-        });
-        expect(result).toMatch(/Previous attempt failed verification/);
-        expect(result).toContain(verifyError);
-        expect(warnSpy).toHaveBeenCalledOnce();
-        expect(warnSpy.mock.calls[0][0]).toMatch(/reflection/i);
-    });
-    it("falls back to default preamble when claude.ask returns empty string", async () => {
-        const claude = fakeClaude("   ");
-        const warnSpy = vi.fn();
-        const logger = { ...silentLogger, warn: warnSpy };
-        const result = await buildRetryPreamble({
-            retry: { max: 1, instruction: { auto: true } },
-            verifyError,
-            context: {},
-            toolCalls: [],
-            nodeInstruction,
-            claude,
-            logger,
-        });
-        expect(result).toMatch(/Previous attempt failed verification/);
-        expect(warnSpy).toHaveBeenCalledOnce();
-    });
-    it("includes tool call summary in reflection prompt (names + ok/error)", async () => {
-        const claude = fakeClaude("ok");
-        const askSpy = claude.ask;
-        await buildRetryPreamble({
-            retry: { max: 1, instruction: { auto: true } },
-            verifyError,
-            context: {},
-            toolCalls: [tc("foo", { ok: true }), tc("bar", { error: "boom" })],
-            nodeInstruction,
-            claude,
-            logger: silentLogger,
-        });
-        const promptText = askSpy.mock.calls[0][0].instruction;
-        expect(promptText).toContain("foo");
-        expect(promptText).toContain("bar");
-        expect(promptText).toMatch(/error/i);
-    });
-    // ── Test 5: whitespace-only ask response falls back to default preamble ──
-    it("falls back to default preamble when claude.ask returns whitespace-only string", async () => {
-        // Locks the trim() behavior at retry.ts:54 — whitespace-only is treated as empty.
-        const warnSpy = vi.fn();
-        const logger = { ...silentLogger, warn: warnSpy };
-        const claude = fakeClaude("\n\n\t   ");
-        const result = await buildRetryPreamble({
-            retry: { max: 1, instruction: { auto: true } },
-            verifyError,
-            context: {},
-            toolCalls: [],
-            nodeInstruction,
-            claude,
-            logger,
-        });
-        expect(result).toMatch(/Previous attempt failed verification/);
-        expect(result).toContain(verifyError);
-        expect(warnSpy).toHaveBeenCalledOnce();
-        expect(warnSpy.mock.calls[0][0]).toMatch(/empty/i);
-    });
-    // ── Test 6: nodeInstruction containing the same header as defaultPreamble ──
-    it("produces a correct preamble even when nodeInstruction contains the default header verbatim", async () => {
-        // Regression: if buildReflectionPrompt did brittle string-replace on the header,
-        // embedding the header in the instruction would corrupt output. Assert it still
-        // produces a preamble starting with "## Reflection on previous attempt".
-        const tricky = "## Previous attempt failed verification\nDo the thing anyway.";
-        const claude = fakeClaude("Here is my diagnosis.");
-        const result = await buildRetryPreamble({
-            retry: { max: 1, instruction: { auto: true } },
-            verifyError,
-            context: {},
-            toolCalls: [],
-            nodeInstruction: tricky,
-            claude,
-            logger: silentLogger,
-        });
-        // The returned preamble should start with the reflection header, not the
-        // default header, because claude.ask returned a non-empty string.
-        expect(result).toMatch(/^## Reflection on previous attempt/);
-        expect(result).toContain("Here is my diagnosis.");
-        expect(result).toContain(verifyError);
-    });
-    // ── Test 7: instruction.reflect = "" (empty string, bypasses Zod) ──
-    it("uses empty string as reflect prompt when reflect is '' (documents current behavior)", async () => {
-        // Zod schema requires reflect: string.min(1), but programmatic construction
-        // can bypass it. Current code: `typeof inst.reflect === "string" ? inst.reflect : DEFAULT`
-        // An empty string IS a string, so it gets used verbatim — the reflection prompt
-        // sent to claude.ask will contain the empty reflect line.
-        // FUTURE: consider falling back to DEFAULT_REFLECTION_PROMPT on empty reflect.
-        const claude = fakeClaude("diagnosis from empty reflect.");
-        const askSpy = claude.ask;
-        await buildRetryPreamble({
-            // Cast to bypass TypeScript's NodeRetry type (which mirrors Zod min(1))
-            retry: { max: 1, instruction: { reflect: "" } },
-            verifyError,
-            context: {},
-            toolCalls: [],
-            nodeInstruction,
-            claude,
-            logger: silentLogger,
-        });
-        expect(askSpy).toHaveBeenCalledOnce();
-        // The reflection prompt is built from the empty string — it should NOT contain
-        // the default "Briefly diagnose" text because reflect="" was used instead.
-        const sentInstruction = askSpy.mock.calls[0][0].instruction;
-        expect(sentInstruction).not.toContain("Briefly diagnose");
-        // The verify error is always included regardless of reflect content.
-        expect(sentInstruction).toContain(verifyError);
-    });
-});

package/dist/__tests__/schema.test.d.ts

@@ -1 +0,0 @@
-export {};