@sweny-ai/core 0.1.77 → 0.1.78

package/dist/templates.js

@@ -1,13 +1,15 @@
 /**
- * Template loading for issues and PRs.
+ * Template + rules/context loading for the CLI.
  *
- * Templates can come from:
+ * Templates and additional-context documents can come from:
  *   1. Local file path (relative to repo root)
  *   2. URL (fetched at runtime)
- *   3. Built-in defaults
+ *   3. Built-in defaults / inline text
  *
- * Delegates to sources.ts for actual resolution; this module provides
- * backwards-compatible wrappers with fallback semantics.
+ * Delegates to source-resolver.ts for the actual fetch. Fix #16: both
+ * `loadTemplate` and `loadAdditionalContext` now honor `offline` and
+ * `fetchAuth` the same way the executor's per-node Sources do, so CLI-level
+ * rules/context stay consistent with everything the executor touches later.
  */
 import * as path from "node:path";
 import { classifySource } from "./sources.js";
@@ -50,39 +52,43 @@ export const DEFAULT_PR_TEMPLATE = `## Summary
 ## Related Issues
 Fixes #
 `;
-/** Default resolution context used by template helpers. */
-function defaultCtx(cwd) {
+function buildCtx(options) {
     return {
-        cwd,
-        env: process.env,
-        authConfig: {},
-        offline: false,
+        cwd: options.cwd ?? process.cwd(),
+        env: options.env ?? process.env,
+        authConfig: options.fetchAuth ?? {},
+        offline: options.offline ?? false,
         logger: consoleLogger,
     };
 }
 /**
  * Load a template from a file path or URL.
  * Returns the default if source is empty or loading fails.
+ *
+ * Accepts the legacy `cwd?: string` signature for backward compat.
  */
-export async function loadTemplate(source, fallback, cwd = process.cwd()) {
+export async function loadTemplate(source, fallback, options = {}) {
     if (!source || source.trim() === "")
         return fallback;
+    const opts = typeof options === "string" ? { cwd: options } : options;
     try {
-        const resolved = await resolveSource(source.trim(), "template", defaultCtx(cwd));
+        const resolved = await resolveSource(source.trim(), "template", buildCtx(opts));
         return resolved.content;
     }
     catch (err) {
-        console.warn(`[templates] Failed to load template: ${err.message}, using default`);
+        const msg = err instanceof Error ? err.message : String(err);
+        console.warn(`[templates] Failed to load template: ${msg}, using default`);
         return fallback;
     }
 }
 /**
  * Resolve issue and PR templates from config.
  */
-export async function resolveTemplates(config, cwd) {
+export async function resolveTemplates(config, options = {}) {
+    const opts = typeof options === "string" ? { cwd: options } : options;
     const [issueTemplate, prTemplate] = await Promise.all([
-        loadTemplate(config.issueTemplate, DEFAULT_ISSUE_TEMPLATE, cwd),
-        loadTemplate(config.prTemplate, DEFAULT_PR_TEMPLATE, cwd),
+        loadTemplate(config.issueTemplate, DEFAULT_ISSUE_TEMPLATE, opts),
+        loadTemplate(config.prTemplate, DEFAULT_PR_TEMPLATE, opts),
     ]);
     return { issueTemplate, prTemplate };
 }
@@ -91,12 +97,15 @@ export async function resolveTemplates(config, cwd) {
  * Each source is resolved eagerly (including URLs) and wrapped with a header.
  * Returns { resolved, urls } — resolved text for all sources; urls is kept
  * for API compat but will be empty since URLs now resolve eagerly.
+ *
+ * Accepts the legacy `cwd?: string` signature for backward compat.
  */
-export async function loadAdditionalContext(sources, cwd = process.cwd()) {
+export async function loadAdditionalContext(sources, options = {}) {
     if (sources.length === 0)
         return { resolved: "", urls: [] };
+    const opts = typeof options === "string" ? { cwd: options } : options;
     const parts = [];
-    const ctx = defaultCtx(cwd);
+    const ctx = buildCtx(opts);
     for (const source of sources) {
         const trimmed = source.trim();
         if (!trimmed)
@@ -114,7 +123,8 @@ export async function loadAdditionalContext(sources, cwd = process.cwd()) {
                 }
             }
             catch (err) {
-                console.warn(`[templates] Failed to load context source: ${err.message}`);
+                const msg = err instanceof Error ? err.message : String(err);
+                console.warn(`[templates] Failed to load context source: ${msg}`);
             }
         }
     }

package/dist/types.d.ts

@@ -201,6 +201,18 @@ export interface ToolCall {
     tool: string;
     input: unknown;
     output?: unknown;
+    /**
+     * Authoritative outcome of the tool invocation.
+     *
+     * When present, this is the source of truth for `verify` checks — the
+     * output-shape heuristic is a legacy fallback only. Set by the Claude
+     * runtime on tool completion: "success" when the tool returned normally,
+     * "error" when it threw or the MCP server returned is_error=true.
+     *
+     * Absent status indicates a legacy or hand-constructed ToolCall — verify
+     * falls back to inspecting `output` for an `error` key.
+     */
+    status?: "success" | "error";
 }
 export type ExecutionEvent = {
     type: "workflow:start";

package/dist/verify.js

@@ -69,19 +69,35 @@ export function resolvePath(data, path) {
     }
     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.
+// Legacy output-shape heuristic: a tool call "succeeded" when its output
+// does not carry a non-null `error` field. Kept as a fallback for ToolCall
+// records that predate the explicit `status` field (hand-constructed in
+// tests, older runtimes). The Claude runtime now sets `status` directly.
 export function isErrorOutput(output) {
     if (!output || typeof output !== "object")
         return false;
     const err = output.error;
     return err !== undefined && err !== null && err !== false;
 }
+/**
+ * A tool call is considered successful when:
+ *   - explicit `status === "success"`, OR
+ *   - no explicit status AND output does not look like an error.
+ *
+ * `status` is authoritative. It's the only signal we have for external MCP
+ * tools whose structured output isn't exposed to the workflow runtime.
+ */
+function didSucceed(c) {
+    if (c.status === "error")
+        return false;
+    if (c.status === "success")
+        return true;
+    return !isErrorOutput(c.output);
+}
 function succeededTools(toolCalls) {
     const names = new Set();
     for (const c of toolCalls) {
-        if (!isErrorOutput(c.output))
+        if (didSucceed(c))
             names.add(c.tool);
     }
     return names;
@@ -180,8 +196,30 @@ export function checkOutputRequired(paths, data) {
         return null;
     return `output_required: ${failures.join("; ")}`;
 }
+/**
+ * Cap on `verify.output_matches[].matches` source length.
+ *
+ * `matches` is user-supplied through workflow YAML, including marketplace
+ * workflows. A pathological pattern like `(a+)+$` causes exponential
+ * backtracking in V8's regex engine. Capping the source length is a cheap,
+ * useful defense — well-formed verify regexes are tens of characters at
+ * most. Patterns longer than this are almost always either generated junk
+ * or a deliberate ReDoS attempt; either way, refusing to compile is safer
+ * than executing them.
+ *
+ * Caveat: length alone does NOT prevent all ReDoS — a 12-char pattern like
+ * `(a+)+$` is still catastrophic against the right input. Future work:
+ * gate compilation through `safe-regex` or use the `re2` engine for
+ * marketplace inputs. The cap closes the obvious abuse surface without
+ * adding a runtime dep right now.
+ */
+const MAX_REGEX_SOURCE_LENGTH = 1000;
 function compileMatch(m) {
     if (m.matches !== undefined) {
+        if (m.matches.length > MAX_REGEX_SOURCE_LENGTH) {
+            throw new Error(`regex source exceeds ${MAX_REGEX_SOURCE_LENGTH} characters (got ${m.matches.length}); ` +
+                `tighten the pattern to avoid catastrophic-backtracking risk`);
+        }
         // 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) };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sweny-ai/core",
-  "version": "0.1.77",
+  "version": "0.1.78",
   "type": "module",
   "bin": {
     "sweny": "./dist/cli/main.js"
@@ -46,10 +46,11 @@
     "dist"
   ],
   "scripts": {
-    "build": "rm -rf dist && tsc && cp src/workflows/*.yml dist/workflows/ && node scripts/build-workflow-browser.mjs",
+    "build": "rm -rf dist && tsc -p tsconfig.build.json && cp src/workflows/*.yml dist/workflows/ && node scripts/build-workflow-browser.mjs && node scripts/write-public-schema.mjs",
     "typecheck": "tsc --noEmit",
-    "test": "vitest run --exclude 'src/__tests__/integration/**'",
-    "test:integration": "vitest run --config vitest.integration.config.ts"
+    "test": "vitest run --exclude 'src/__tests__/integration/**' --exclude 'dist/**'",
+    "test:integration": "vitest run --config vitest.integration.config.ts",
+    "check:schema-drift": "node scripts/write-public-schema.mjs && git diff --exit-code -- ../../spec/public/schemas/workflow.json"
   },
   "dependencies": {
     "@anthropic-ai/claude-agent-sdk": "^0.2.114",
@@ -61,6 +62,9 @@
   },
   "devDependencies": {
     "@anthropic-ai/claude-code": "^2.1.114",
+    "ajv": "^8.18.0",
+    "esbuild": "^0.28.0",
+    "prettier": "^3.8.3",
     "vitest": "^4.1.4"
   },
   "publishConfig": {

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

@@ -1,11 +0,0 @@
-/**
- * Rules / Context Cascade + max_turns Tests
- *
- * Covers the spec sections:
- * - Workflow > Rules & Context
- * - Workflow > Runtime Input (rules/context)
- * - Nodes > Max Turns Semantics
- * - Nodes > Rules & Context (cascade + `only` flag)
- * - Nodes > Input Augmentation (assembly order)
- */
-export {};