@sweny-ai/core 0.1.76 → 0.1.78

package/dist/requires.d.ts

@@ -0,0 +1,7 @@
+import type { NodeRequires } from "./types.js";
+/**
+ * Evaluate a node's `requires` block against the cross-node context map.
+ * Returns null when all checks pass (or when `requires` is undefined),
+ * otherwise a single concatenated failure string.
+ */
+export declare function evaluateRequires(requires: NodeRequires | undefined, context: Record<string, unknown>): string | null;

package/dist/requires.js

@@ -0,0 +1,34 @@
+// ─── Requires: pre-condition gate ───────────────────────────────────
+//
+// Evaluates `node.requires` BEFORE the LLM runs. Same path grammar and
+// resolver as verify — the only differences are the data root (cross-node
+// context map instead of result.data) and the error prefix.
+import { checkOutputRequired, checkOutputMatches } from "./verify.js";
+/**
+ * Evaluate a node's `requires` block against the cross-node context map.
+ * Returns null when all checks pass (or when `requires` is undefined),
+ * otherwise a single concatenated failure string.
+ */
+export function evaluateRequires(requires, context) {
+    if (!requires)
+        return null;
+    const hasRequiredChecks = requires.output_required && requires.output_required.length > 0;
+    const hasMatchChecks = requires.output_matches && requires.output_matches.length > 0;
+    if (!hasRequiredChecks && !hasMatchChecks) {
+        return `requires failed:\n  - Requires block present but no checks declared`;
+    }
+    const failures = [];
+    if (hasRequiredChecks) {
+        const e = checkOutputRequired(requires.output_required, context);
+        if (e)
+            failures.push(e);
+    }
+    if (hasMatchChecks) {
+        const e = checkOutputMatches(requires.output_matches, context);
+        if (e)
+            failures.push(e);
+    }
+    if (failures.length === 0)
+        return null;
+    return `requires failed:\n  - ${failures.join("\n  - ")}`;
+}

package/dist/retry.d.ts

@@ -0,0 +1,23 @@
+import type { Claude, NodeRetry, ToolCall, Logger } from "./types.js";
+export interface BuildRetryPreambleOptions {
+    retry: NodeRetry;
+    verifyError: string;
+    toolCalls: ToolCall[];
+    nodeInstruction: string;
+    claude: Claude;
+    logger: Logger;
+    context: Record<string, unknown>;
+}
+/**
+ * Build the retry preamble for a single retry attempt.
+ *
+ * Resolution order:
+ *   1. retry.instruction is a string         → static preamble + verify error
+ *   2. retry.instruction is { auto: true }   → claude.ask(default prompt)
+ *   3. retry.instruction is { reflect: "..." } → claude.ask(author prompt)
+ *   4. Otherwise (omitted)                   → default preamble
+ *
+ * Reflection failure (throw or empty response) silently falls back to the
+ * default static preamble and logs a warning.
+ */
+export declare function buildRetryPreamble(opts: BuildRetryPreambleOptions): Promise<string>;

package/dist/retry.js

@@ -0,0 +1,72 @@
+// ─── Retry: preamble construction for verify-failure self-healing ──
+//
+// Builds the preamble that gets prepended to the node instruction on retry.
+// In autonomous modes ({ auto: true } or { reflect: ... }), this calls
+// claude.ask to generate a diagnosis. If reflection fails or returns empty,
+// falls back to the default static preamble — reflection failure never
+// escalates to a workflow failure.
+import { isErrorOutput } from "./verify.js";
+const DEFAULT_REFLECTION_PROMPT = "Briefly diagnose the failure and state your strategy for the retry. Keep your response to 2-4 sentences.";
+const DEFAULT_PREAMBLE_HEADER = "## Previous attempt failed verification";
+/**
+ * Build the retry preamble for a single retry attempt.
+ *
+ * Resolution order:
+ *   1. retry.instruction is a string         → static preamble + verify error
+ *   2. retry.instruction is { auto: true }   → claude.ask(default prompt)
+ *   3. retry.instruction is { reflect: "..." } → claude.ask(author prompt)
+ *   4. Otherwise (omitted)                   → default preamble
+ *
+ * Reflection failure (throw or empty response) silently falls back to the
+ * default static preamble and logs a warning.
+ */
+export async function buildRetryPreamble(opts) {
+    const { retry, verifyError, toolCalls, nodeInstruction, claude, logger, context } = opts;
+    const inst = retry.instruction;
+    if (typeof inst === "string") {
+        return `## Retry guidance\n\n${inst}\n\n${DEFAULT_PREAMBLE_HEADER}\n\n${verifyError}`;
+    }
+    if (inst && typeof inst === "object") {
+        const reflectPrompt = "reflect" in inst && typeof inst.reflect === "string" ? inst.reflect : DEFAULT_REFLECTION_PROMPT;
+        const askInstruction = buildReflectionPrompt(reflectPrompt, nodeInstruction, verifyError, toolCalls);
+        try {
+            const diagnosis = await claude.ask({ instruction: askInstruction, context });
+            const trimmed = diagnosis.trim();
+            if (trimmed.length > 0) {
+                return `## Reflection on previous attempt\n\n${trimmed}\n\n${DEFAULT_PREAMBLE_HEADER}\n\n${verifyError}`;
+            }
+            logger.warn("Retry reflection returned empty response; falling back to default preamble.");
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            logger.warn(`Retry reflection threw: ${msg}; falling back to default preamble.`);
+        }
+    }
+    return defaultPreamble(verifyError);
+}
+function defaultPreamble(verifyError) {
+    return `${DEFAULT_PREAMBLE_HEADER}\n\n${verifyError}\n\nFix the issue and try again.`;
+}
+function buildReflectionPrompt(reflectPrompt, nodeInstruction, verifyError, toolCalls) {
+    const summary = summarizeToolCalls(toolCalls);
+    return [
+        `You attempted to: ${nodeInstruction}`,
+        "",
+        `Verification failed with: ${verifyError}`,
+        "",
+        `You called these tools during the failed attempt:`,
+        summary,
+        "",
+        reflectPrompt,
+    ].join("\n");
+}
+function summarizeToolCalls(toolCalls) {
+    if (toolCalls.length === 0)
+        return "(no tools were called)";
+    return toolCalls
+        .map((c) => {
+        const status = isErrorOutput(c.output) ? "error" : "ok";
+        return `  - ${c.tool} (${status})`;
+    })
+        .join("\n");
+}