@sweny-ai/core 0.1.77 → 0.1.79

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;
@@ -89,22 +105,73 @@ function succeededTools(toolCalls) {
 function calledList(toolCalls) {
     return toolCalls.map((c) => c.tool).join(", ") || "none";
 }
+// Tool aliases: first-party SWEny skill tool names ↔ their MCP-server equivalents.
+//
+// When an external MCP server is wired for the same provider a skill covers
+// (e.g. the Linear HTTP MCP server alongside the `linear` skill), both sets of
+// tools are presented to the agent and the agent may pick either. The calls
+// are functionally equivalent — same backend, same effect — but the names
+// differ, so a verify rule that lists one will fail when the agent picked the
+// other. These aliases let either call satisfy the rule.
+//
+// Only unambiguous MCP tool names are aliased. Names that collide across
+// providers (e.g. `get_issue` exists on both Linear and GitHub MCP servers)
+// are deliberately omitted so a call to one provider cannot spuriously
+// satisfy a rule about the other.
+const TOOL_ALIAS_GROUPS = [
+    // Linear (official remote MCP at mcp.linear.app — upsert naming)
+    ["linear_search_issues", "list_issues"],
+    ["linear_create_issue", "save_issue"],
+    ["linear_update_issue", "save_issue"],
+    ["linear_add_comment", "save_comment"],
+    ["linear_list_teams", "list_teams"],
+    // GitHub (github.com/github/github-mcp-server)
+    ["github_create_issue", "create_issue"],
+    ["github_search_issues", "search_issues"],
+    ["github_add_comment", "add_issue_comment"],
+    ["github_create_pr", "create_pull_request"],
+];
+const TOOL_ALIASES = (() => {
+    const map = new Map();
+    for (const group of TOOL_ALIAS_GROUPS) {
+        for (const name of group) {
+            let set = map.get(name);
+            if (!set) {
+                set = new Set();
+                map.set(name, set);
+            }
+            for (const other of group)
+                set.add(other);
+        }
+    }
+    return map;
+})();
+function expandAliases(name) {
+    return TOOL_ALIASES.get(name) ?? new Set([name]);
+}
+function anyAliasIn(name, set) {
+    for (const alias of expandAliases(name)) {
+        if (set.has(alias))
+            return true;
+    }
+    return false;
+}
 export function checkAnyToolCalled(required, toolCalls) {
     const succeeded = succeededTools(toolCalls);
-    if (required.some((t) => succeeded.has(t)))
+    if (required.some((t) => anyAliasIn(t, succeeded)))
         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));
+    const missing = required.filter((t) => !anyAliasIn(t, succeeded));
     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));
+    const violated = forbidden.filter((t) => anyAliasIn(t, calledNames));
     if (violated.length === 0)
         return null;
     return `no_tool_called: forbidden tools were invoked: [${violated.join(", ")}], called: [${calledList(toolCalls)}]`;
@@ -180,8 +247,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.79",
   "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 {};