@sweny-ai/core 0.1.73 → 0.1.75

package/dist/verify.js

@@ -0,0 +1,309 @@
+// ─── Verify: path resolver + check evaluators ───────────────────────
+//
+// Evaluates `node.verify` post-conditions after the LLM finishes.
+// All checks are AND-ed; failures are aggregated into one error string.
+const SEGMENT_RE = /^([a-zA-Z_][a-zA-Z0-9_]*)(\[\*\])?$/;
+const PREFIX_RE = /^([a-z]+):/;
+function parsePath(path) {
+    if (path.length === 0)
+        return "empty path";
+    let mode = "all";
+    let body = path;
+    const prefixMatch = PREFIX_RE.exec(path);
+    if (prefixMatch) {
+        const prefix = prefixMatch[1];
+        if (prefix !== "all" && prefix !== "any") {
+            return `unknown prefix '${prefix}' (expected 'all' or 'any')`;
+        }
+        mode = prefix;
+        body = path.slice(prefixMatch[0].length);
+        if (body.length === 0)
+            return "empty path after prefix";
+    }
+    const parts = body.split(".");
+    const segments = [];
+    for (const part of parts) {
+        const m = SEGMENT_RE.exec(part);
+        if (!m)
+            return `malformed segment '${part}'`;
+        segments.push({ name: m[1], wildcard: m[2] === "[*]" });
+    }
+    return { mode, segments };
+}
+export function resolvePath(data, path) {
+    const parsed = parsePath(path);
+    if (typeof parsed === "string")
+        return { ok: false, reason: parsed };
+    let current = [data];
+    for (const seg of parsed.segments) {
+        const next = [];
+        for (const v of current) {
+            if (v === null)
+                return { ok: false, reason: `null encountered before segment '${seg.name}'` };
+            if (typeof v !== "object") {
+                return { ok: false, reason: `expected object before segment '${seg.name}', got ${typeof v}` };
+            }
+            const obj = v;
+            if (!(seg.name in obj)) {
+                return { ok: false, reason: `missing segment '${seg.name}'` };
+            }
+            const child = obj[seg.name];
+            if (seg.wildcard) {
+                if (!Array.isArray(child)) {
+                    return {
+                        ok: false,
+                        reason: `expected array at '${seg.name}', got ${child === null ? "null" : typeof child}`,
+                    };
+                }
+                for (const el of child)
+                    next.push(el);
+            }
+            else {
+                next.push(child);
+            }
+        }
+        current = next;
+        if (current.length === 0) {
+            return { ok: true, mode: parsed.mode, values: [] };
+        }
+    }
+    return { ok: true, mode: parsed.mode, values: current };
+}
+// A tool call "succeeded" when its output does not carry a non-null `error` field.
+// `{ error: null }` and `{ error: false }` are treated as success — many real
+// tools include the key with a null sentinel.
+function isErrorOutput(output) {
+    if (!output || typeof output !== "object")
+        return false;
+    const err = output.error;
+    return err !== undefined && err !== null && err !== false;
+}
+function succeededTools(toolCalls) {
+    const names = new Set();
+    for (const c of toolCalls) {
+        if (!isErrorOutput(c.output))
+            names.add(c.tool);
+    }
+    return names;
+}
+function calledList(toolCalls) {
+    return toolCalls.map((c) => c.tool).join(", ") || "none";
+}
+export function checkAnyToolCalled(required, toolCalls) {
+    const succeeded = succeededTools(toolCalls);
+    if (required.some((t) => succeeded.has(t)))
+        return null;
+    return `any_tool_called: required one of [${required.join(", ")}] to succeed, called: [${calledList(toolCalls)}]`;
+}
+export function checkAllToolsCalled(required, toolCalls) {
+    const succeeded = succeededTools(toolCalls);
+    const missing = required.filter((t) => !succeeded.has(t));
+    if (missing.length === 0)
+        return null;
+    return `all_tools_called: missing successful calls to [${missing.join(", ")}], called: [${calledList(toolCalls)}]`;
+}
+export function checkNoToolCalled(forbidden, toolCalls) {
+    const calledNames = new Set(toolCalls.map((c) => c.tool));
+    const violated = forbidden.filter((t) => calledNames.has(t));
+    if (violated.length === 0)
+        return null;
+    return `no_tool_called: forbidden tools were invoked: [${violated.join(", ")}], called: [${calledList(toolCalls)}]`;
+}
+// Structural deep equality for JSON-shaped values. Handles object key-order
+// (compares by key set, not insertion order), NaN (NaN === NaN here), arrays
+// (element-wise), and treats `undefined` distinctly from missing keys. Does
+// not handle Date/Map/Set/RegExp — verify only ever sees agent-produced JSON.
+function deepEqual(a, b) {
+    if (Object.is(a, b))
+        return true;
+    if (typeof a !== typeof b)
+        return false;
+    if (a === null || b === null)
+        return false;
+    if (typeof a !== "object")
+        return false;
+    if (Array.isArray(a)) {
+        if (!Array.isArray(b) || a.length !== b.length)
+            return false;
+        for (let i = 0; i < a.length; i++) {
+            if (!deepEqual(a[i], b[i]))
+                return false;
+        }
+        return true;
+    }
+    if (Array.isArray(b))
+        return false;
+    const ao = a;
+    const bo = b;
+    const aKeys = Object.keys(ao);
+    const bKeys = Object.keys(bo);
+    if (aKeys.length !== bKeys.length)
+        return false;
+    for (const k of aKeys) {
+        if (!Object.prototype.hasOwnProperty.call(bo, k))
+            return false;
+        if (!deepEqual(ao[k], bo[k]))
+            return false;
+    }
+    return true;
+}
+function formatValue(v) {
+    if (v === null)
+        return "null";
+    if (v === undefined)
+        return "undefined";
+    return JSON.stringify(v);
+}
+export function checkOutputRequired(paths, data) {
+    const failures = [];
+    for (const path of paths) {
+        const r = resolvePath(data, path);
+        if (!r.ok) {
+            failures.push(`'${path}' ${r.reason}`);
+            continue;
+        }
+        if (r.mode === "all") {
+            if (r.values.length > 0 && !r.values.every((v) => v !== null && v !== undefined)) {
+                failures.push(`'${path}' resolved to null/undefined value(s)`);
+            }
+        }
+        else {
+            if (r.values.length === 0) {
+                failures.push(`'${path}' (any:) resolved to no elements`);
+            }
+            else if (!r.values.some((v) => v !== null && v !== undefined)) {
+                failures.push(`'${path}' (any:) all resolved values are null/undefined`);
+            }
+        }
+    }
+    if (failures.length === 0)
+        return null;
+    return `output_required: ${failures.join("; ")}`;
+}
+function compileMatch(m) {
+    if (m.matches !== undefined) {
+        // Throws synchronously if the regex source is invalid; surfaced as a
+        // verify failure rather than a crash because the executor catches.
+        return { match: m, regex: new RegExp(m.matches) };
+    }
+    return { match: m };
+}
+function applyOperator(c, value) {
+    const m = c.match;
+    if (m.equals !== undefined) {
+        if (deepEqual(value, m.equals))
+            return { ok: true };
+        return { ok: false, reason: `equals ${formatValue(m.equals)}, got ${formatValue(value)}` };
+    }
+    if (m.in !== undefined) {
+        if (m.in.some((x) => deepEqual(value, x)))
+            return { ok: true };
+        return {
+            ok: false,
+            reason: `in [${m.in.map(formatValue).join(", ")}], got ${formatValue(value)}`,
+        };
+    }
+    if (c.regex) {
+        const s = typeof value === "string" ? value : JSON.stringify(value);
+        if (c.regex.test(s))
+            return { ok: true };
+        return { ok: false, reason: `matches /${m.matches}/, got ${formatValue(value)}` };
+    }
+    return { ok: false, reason: "no operator declared (zod should have caught this)" };
+}
+export function checkOutputMatches(matches, data) {
+    const failures = [];
+    for (const m of matches) {
+        let compiled;
+        try {
+            compiled = compileMatch(m);
+        }
+        catch (err) {
+            failures.push(`'${m.path}' invalid regex /${m.matches}/: ${err.message}`);
+            continue;
+        }
+        const r = resolvePath(data, m.path);
+        if (!r.ok) {
+            failures.push(`'${m.path}' ${r.reason}`);
+            continue;
+        }
+        if (r.mode === "all") {
+            if (r.values.length === 0)
+                continue;
+            const offenders = [];
+            for (const v of r.values) {
+                const res = applyOperator(compiled, v);
+                if (!res.ok)
+                    offenders.push(formatValue(v));
+            }
+            if (offenders.length > 0) {
+                const opDescription = describeOperator(compiled);
+                failures.push(`'${m.path}' ${opDescription}, got [${offenders.join(", ")}]`);
+            }
+        }
+        else {
+            if (r.values.length === 0) {
+                failures.push(`'${m.path}' (any:) resolved to no elements`);
+                continue;
+            }
+            const anyOk = r.values.some((v) => applyOperator(compiled, v).ok);
+            if (!anyOk) {
+                const opDescription = describeOperator(compiled);
+                failures.push(`'${m.path}' (any:) no element satisfies ${opDescription}`);
+            }
+        }
+    }
+    if (failures.length === 0)
+        return null;
+    return `output_matches: ${failures.join("; ")}`;
+}
+function describeOperator(c) {
+    const m = c.match;
+    if (m.equals !== undefined)
+        return `equals ${formatValue(m.equals)}`;
+    if (m.in !== undefined)
+        return `in [${m.in.map(formatValue).join(", ")}]`;
+    if (m.matches !== undefined)
+        return `matches /${m.matches}/`;
+    return "no operator";
+}
+/**
+ * Evaluate every declared check and return a concatenated error string,
+ * or null when the node passes verification (or has no verify block).
+ *
+ * Deterministic and side-effect free — the executor calls this synchronously
+ * after the LLM finishes.
+ */
+export function evaluateVerify(verify, result) {
+    if (!verify)
+        return null;
+    const failures = [];
+    if (verify.any_tool_called && verify.any_tool_called.length > 0) {
+        const e = checkAnyToolCalled(verify.any_tool_called, result.toolCalls);
+        if (e)
+            failures.push(e);
+    }
+    if (verify.all_tools_called && verify.all_tools_called.length > 0) {
+        const e = checkAllToolsCalled(verify.all_tools_called, result.toolCalls);
+        if (e)
+            failures.push(e);
+    }
+    if (verify.no_tool_called && verify.no_tool_called.length > 0) {
+        const e = checkNoToolCalled(verify.no_tool_called, result.toolCalls);
+        if (e)
+            failures.push(e);
+    }
+    if (verify.output_required && verify.output_required.length > 0) {
+        const e = checkOutputRequired(verify.output_required, result.data);
+        if (e)
+            failures.push(e);
+    }
+    if (verify.output_matches && verify.output_matches.length > 0) {
+        const e = checkOutputMatches(verify.output_matches, result.data);
+        if (e)
+            failures.push(e);
+    }
+    if (failures.length === 0)
+        return null;
+    return `verify failed:\n  - ${failures.join("\n  - ")}`;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sweny-ai/core",
-  "version": "0.1.73",
+  "version": "0.1.75",
   "type": "module",
   "bin": {
     "sweny": "./dist/cli/main.js"
@@ -52,7 +52,7 @@
     "test:integration": "vitest run --config vitest.integration.config.ts"
   },
   "dependencies": {
-    "@anthropic-ai/claude-agent-sdk": "^0.2.92",
+    "@anthropic-ai/claude-agent-sdk": "^0.2.114",
     "@clack/prompts": "^1.2.0",
     "chalk": "^5",
     "commander": "^13",