@sweny-ai/core 0.1.76 → 0.1.77

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

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

package/dist/__tests__/requires.test.js

@@ -0,0 +1,82 @@
+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

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

package/dist/__tests__/retry.test.js

@@ -0,0 +1,213 @@
+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.js

@@ -1,5 +1,5 @@
 import { describe, it, expect } from "vitest";
-import { workflowZ, nodeZ, nodeVerifyZ, edgeZ, skillZ, toolZ, mcpServerConfigZ, skillDefinitionZ, parseWorkflow, validateWorkflow, workflowJsonSchema, } from "../schema.js";
+import { workflowZ, nodeZ, nodeVerifyZ, nodeRequiresZ, nodeRetryZ, edgeZ, skillZ, toolZ, mcpServerConfigZ, skillDefinitionZ, parseWorkflow, validateWorkflow, workflowJsonSchema, } from "../schema.js";
 import { triageWorkflow, implementWorkflow } from "../workflows/index.js";
 // ─── Test fixtures ───────────────────────────────────────────────
 const validWorkflow = {
@@ -125,6 +125,80 @@ describe("Zod schemas", () => {
             expect(() => nodeVerifyZ.parse({ output_matches: [] })).toThrow();
         });
     });
+    describe("nodeRequiresZ", () => {
+        it("accepts output_required only", () => {
+            expect(() => nodeRequiresZ.parse({ output_required: ["input.x"] })).not.toThrow();
+        });
+        it("accepts output_matches only", () => {
+            expect(() => nodeRequiresZ.parse({ output_matches: [{ path: "input.x", equals: 1 }] })).not.toThrow();
+        });
+        it("accepts on_fail: 'fail'", () => {
+            expect(() => nodeRequiresZ.parse({ output_required: ["input.x"], on_fail: "fail" })).not.toThrow();
+        });
+        it("accepts on_fail: 'skip'", () => {
+            expect(() => nodeRequiresZ.parse({ output_required: ["input.x"], on_fail: "skip" })).not.toThrow();
+        });
+        it("rejects empty requires (no checks declared)", () => {
+            expect(() => nodeRequiresZ.parse({})).toThrow();
+        });
+        it("rejects on_fail other than 'fail' or 'skip'", () => {
+            expect(() => nodeRequiresZ.parse({ output_required: ["input.x"], on_fail: "throw" })).toThrow();
+        });
+        it("rejects empty output_required array", () => {
+            expect(() => nodeRequiresZ.parse({ output_required: [] })).toThrow();
+        });
+        it("nodeZ accepts a node with requires", () => {
+            expect(() => nodeZ.parse({
+                name: "Test",
+                instruction: "Do thing",
+                skills: [],
+                requires: { output_required: ["input.x"] },
+            })).not.toThrow();
+        });
+    });
+    describe("nodeRetryZ", () => {
+        it("accepts max alone", () => {
+            expect(() => nodeRetryZ.parse({ max: 2 })).not.toThrow();
+        });
+        it("accepts max + string instruction", () => {
+            expect(() => nodeRetryZ.parse({ max: 1, instruction: "Try harder" })).not.toThrow();
+        });
+        it("accepts max + { auto: true }", () => {
+            expect(() => nodeRetryZ.parse({ max: 1, instruction: { auto: true } })).not.toThrow();
+        });
+        it("accepts max + { reflect: '...' }", () => {
+            expect(() => nodeRetryZ.parse({ max: 1, instruction: { reflect: "Focus on tool calls" } })).not.toThrow();
+        });
+        it("rejects max: 0", () => {
+            expect(() => nodeRetryZ.parse({ max: 0 })).toThrow();
+        });
+        it("rejects negative max", () => {
+            expect(() => nodeRetryZ.parse({ max: -1 })).toThrow();
+        });
+        it("rejects non-integer max", () => {
+            expect(() => nodeRetryZ.parse({ max: 1.5 })).toThrow();
+        });
+        it("rejects { auto: false }", () => {
+            expect(() => nodeRetryZ.parse({ max: 1, instruction: { auto: false } })).toThrow();
+        });
+        it("rejects empty reflect string", () => {
+            expect(() => nodeRetryZ.parse({ max: 1, instruction: { reflect: "" } })).toThrow();
+        });
+        it("rejects instruction with both auto and reflect", () => {
+            expect(() => nodeRetryZ.parse({ max: 1, instruction: { auto: true, reflect: "x" } })).toThrow();
+        });
+        it("requires max field", () => {
+            expect(() => nodeRetryZ.parse({ instruction: "x" })).toThrow();
+        });
+        it("nodeZ accepts a node with retry", () => {
+            expect(() => nodeZ.parse({
+                name: "Test",
+                instruction: "Do thing",
+                skills: [],
+                retry: { max: 2, instruction: { auto: true } },
+            })).not.toThrow();
+        });
+    });
     describe("edgeZ", () => {
         it("parses a simple edge", () => {
             const result = edgeZ.parse({ from: "a", to: "b" });

package/dist/__tests__/spec-conformance.test.js

@@ -937,6 +937,16 @@ describe("spec: JSON Schema", () => {
         const errors = validateWorkflow(result);
         expect(errors).toHaveLength(0);
     });
+    it("workflowJsonSchema declares verify, requires, and retry on node properties", () => {
+        const nodeProps = workflowJsonSchema.properties.nodes.additionalProperties.properties;
+        expect(nodeProps.verify).toBeDefined();
+        expect(nodeProps.requires).toBeDefined();
+        expect(nodeProps.retry).toBeDefined();
+        expect(nodeProps.requires.properties.output_required).toBeDefined();
+        expect(nodeProps.requires.properties.on_fail.enum).toEqual(["fail", "skip"]);
+        expect(nodeProps.retry.properties.max.type).toBe("integer");
+        expect(nodeProps.retry.properties.instruction.oneOf).toBeDefined();
+    });
 });
 // ─── Spec Section: Source Types ──────────────────────────────────
 describe("spec: Source type classification", () => {

package/dist/__tests__/testing.test.js

@@ -155,6 +155,24 @@ describe("MockClaude", () => {
             expect(chosen).toBe("valid"); // falls back to first choice
         });
     });
+    describe("ask", () => {
+        it("returns scripted response from ask handler", async () => {
+            const claude = new MockClaude({
+                responses: {},
+                ask: (instruction, context) => `Got: ${instruction}; ctx keys: ${Object.keys(context).join(",")}`,
+            });
+            const result = await claude.ask({
+                instruction: "diagnose this",
+                context: { error: "x" },
+            });
+            expect(result).toBe("Got: diagnose this; ctx keys: error");
+        });
+        it("returns empty string when no ask handler is provided (exercises default-preamble fallback)", async () => {
+            const claude = new MockClaude({ responses: {} });
+            const result = await claude.ask({ instruction: "anything", context: {} });
+            expect(result).toBe("");
+        });
+    });
 });
 // ─── File skill tests ────────────────────────────────────────────
 describe("createFileSkill", () => {

package/dist/claude.d.ts

@@ -53,4 +53,8 @@ export declare class ClaudeClient implements Claude {
             description: string;
         }[];
     }): Promise<string>;
+    ask(opts: {
+        instruction: string;
+        context: Record<string, unknown>;
+    }): Promise<string>;
 }

package/dist/claude.js

@@ -202,6 +202,47 @@ export class ClaudeClient {
         this.logger.warn(`Could not parse route choice from: "${text.slice(0, 100)}". Falling back to first choice.`);
         return validIds[0];
     }
+    async ask(opts) {
+        const { instruction, context } = opts;
+        const prompt = [
+            instruction,
+            Object.keys(context).length > 0 ? `\nContext:\n\`\`\`json\n${JSON.stringify(context, null, 2)}\n\`\`\`` : "",
+        ]
+            .filter(Boolean)
+            .join("\n");
+        const env = this.buildEnv();
+        let response = "";
+        try {
+            const stream = query({
+                prompt,
+                options: {
+                    maxTurns: 1,
+                    cwd: this.cwd,
+                    env,
+                    permissionMode: "bypassPermissions",
+                    allowDangerouslySkipPermissions: true,
+                    stderr: (data) => this.logger.debug(`[claude-code] ${data}`),
+                    ...(this.model ? { model: this.model } : {}),
+                },
+            });
+            for await (const message of stream) {
+                if (message.type === "result") {
+                    const resultMsg = message;
+                    if (resultMsg.subtype === "success" && "result" in resultMsg) {
+                        response = resultMsg.result;
+                    }
+                    else {
+                        this.logger.warn(`claude.ask: SDK returned non-success subtype "${resultMsg.subtype}" — returning empty string`);
+                    }
+                }
+            }
+        }
+        catch (err) {
+            this.logger.warn(`Ask query failed: ${err.message}`);
+            return "";
+        }
+        return response.trim();
+    }
 }
 // ─── Tool conversion ────────────────────────────────────────────
 /**