@sweny-ai/core 0.1.76 → 0.1.78

package/dist/cli/marketplace.js

@@ -10,7 +10,7 @@ import * as p from "@clack/prompts";
 import { parse as parseYaml, stringify as stringifyYaml } from "yaml";
 import { refineWorkflow } from "../workflow-builder.js";
 import { DagRenderer } from "./renderer.js";
-import { workflowZ, validateWorkflow } from "../schema.js";
+import { validateParsed } from "../loader.js";
 import { loadConfigFile } from "./config-file.js";
 import { extractSkillsFromYaml, collectCredentialsForSkills, writeSwenyYmlIfMissing, appendMissingEnvKeys, writeWorkflowFile, } from "./new.js";
 export const MARKETPLACE_REPO = "swenyai/workflows";
@@ -194,20 +194,36 @@ export async function installMarketplaceWorkflow(id, options) {
     const overwrite = options.overwrite ?? false;
     // 1. Fetch
     const fetched = await fetchMarketplaceWorkflow(id);
-    // 2. Load existing config to detect mismatches
+    // 2. Validate fetched content BEFORE any local side effects (Fix #3).
+    // Previously, an invalid workflow could still get written to disk and
+    // .sweny.yml / .env polluted with keys inferred from broken content.
+    let parsed;
+    {
+        let yamlParsed;
+        try {
+            yamlParsed = parseYaml(fetched.yaml);
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            throw new Error(`Marketplace workflow "${id}" is not valid YAML: ${msg}`);
+        }
+        const validated = validateParsed(yamlParsed);
+        if (!validated.ok) {
+            throw new Error(`Marketplace workflow "${id}" failed validation:\n${validated.errors.map((e) => `  ${e.message}`).join("\n")}`);
+        }
+        parsed = validated.workflow;
+    }
+    // 3. Load existing config to detect mismatches
     const fileConfig = loadConfigFile(cwd);
     const workflowSkills = extractSkillsFromYaml(fetched.yaml);
     const mismatches = computeProviderMismatch(workflowSkills, fileConfig, availableSkills);
-    // 3. Adapt if needed + possible
+    // 4. Adapt if needed + possible. Schema was already validated above, so
+    // adaptation failure no longer hides a schema failure — it falls back to
+    // installing the validated-original.
     let finalYaml = fetched.yaml;
     let adapted = false;
     if (mismatches.length > 0 && claude) {
         try {
-            const parsed = workflowZ.parse(parseYaml(fetched.yaml));
-            const errs = validateWorkflow(parsed);
-            if (errs.length > 0) {
-                throw new Error(`Marketplace workflow has schema errors: ${errs.map((e) => e.message).join("; ")}`);
-            }
             const refined = await adaptWorkflowInteractive(parsed, {
                 claude,
                 skills: availableSkills,
@@ -224,7 +240,17 @@ export async function installMarketplaceWorkflow(id, options) {
                     addedEnvKeys: 0,
                 };
             }
-            finalYaml = stringifyYaml(refined, { indent: 2, lineWidth: 120 });
+            // Re-validate the refined output before writing. refineWorkflow runs
+            // an LLM that produces a new Workflow object — it could drift away
+            // from the upfront-validated parse (renamed required fields, dropped
+            // edges). Reparsing the stringified YAML closes that loop so we
+            // never write content that hasn't been schema-checked.
+            const refinedYaml = stringifyYaml(refined, { indent: 2, lineWidth: 120 });
+            const revalidated = validateParsed(parseYaml(refinedYaml));
+            if (!revalidated.ok) {
+                throw new Error(`Adapted workflow failed re-validation:\n${revalidated.errors.map((e) => `  ${e.message}`).join("\n")}`);
+            }
+            finalYaml = refinedYaml;
             adapted = true;
         }
         catch (err) {

package/dist/cli/publish.d.ts

@@ -32,4 +32,14 @@ export declare function validateSkillDir(dirPath: string): {
     errors: string[];
 };
 export declare function runPublish(): Promise<PublishResult | null>;
+/**
+ * Recursively copy a skill source directory to its destination (Fix #17).
+ *
+ * Previously a flat `fs.readdirSync` + `fs.copyFileSync` loop: skills with
+ * nested directories (scripts/, references/, assets/) either silently
+ * shipped incomplete or — more often — threw EISDIR on the first subdir.
+ *
+ * Exported for tests; node:fs cp's recursive mode preserves structure.
+ */
+export declare function copySkillDir(sourceDir: string, destDir: string): void;
 export declare function registerPublishCommand(program: Command): void;

package/dist/cli/publish.js

@@ -14,7 +14,7 @@ import chalk from "chalk";
 import { parse as parseYaml } from "yaml";
 import { parseWorkflow, validateWorkflow } from "../schema.js";
 import { builtinSkills } from "../skills/index.js";
-import { discoverSkills } from "../skills/custom-loader.js";
+import { discoverSkillsWithDiagnostics } from "../skills/custom-loader.js";
 // ── Types ──────────────────────────────────────────────────────────────
 const VALID_CATEGORIES = ["triage", "security", "devops", "code-review", "testing", "content", "ops"];
 const VALID_SKILL_ID = /^[a-z0-9]([a-z0-9-]*[a-z0-9])?$/;
@@ -35,8 +35,12 @@ export function validateWorkflowFile(filePath) {
     }
     try {
         const workflow = parseWorkflow(parsed);
-        // Build known skill IDs from builtins + custom + inline workflow skills
-        const customSkills = discoverSkills();
+        // Build known skill IDs from builtins + custom + inline workflow skills.
+        // Surface skill-loader diagnostics (malformed frontmatter, invalid ids,
+        // duplicate overrides) so publishers don't ship broken dependencies.
+        const { skills: customSkills, warnings: skillWarnings } = discoverSkillsWithDiagnostics();
+        for (const w of skillWarnings)
+            warnings.push(w.message);
         const allSkillIds = new Set([...builtinSkills.map((s) => s.id), ...customSkills.map((s) => s.id)]);
         // Inline skills defined in the workflow's skills block (a Record<id, def>) are also valid
         if (workflow.skills) {
@@ -343,12 +347,7 @@ async function openGitHubPR(type, id, sourcePath, meta) {
         }
         else {
             const destDir = path.join(tmpDir, "skills", "community", id);
-            fs.mkdirSync(destDir, { recursive: true });
-            // Copy entire skill directory
-            const files = fs.readdirSync(sourcePath);
-            for (const file of files) {
-                fs.copyFileSync(path.join(sourcePath, file), path.join(destDir, file));
-            }
+            copySkillDir(sourcePath, destDir);
             execFileSync("git", ["-C", tmpDir, "add", `skills/community/${id}`], { stdio: "pipe" });
         }
         s.message("Pushing...");
@@ -396,16 +395,25 @@ async function saveLocally(type, id, sourcePath) {
     }
     else {
         const destDir = path.join(outputDir, id);
-        fs.mkdirSync(destDir, { recursive: true });
-        const files = fs.readdirSync(sourcePath);
-        for (const file of files) {
-            fs.copyFileSync(path.join(sourcePath, file), path.join(destDir, file));
-        }
+        copySkillDir(sourcePath, destDir);
         p.log.success(`Saved to ${chalk.cyan(destDir)}`);
         p.log.info(`Submit manually: copy to skills/community/ in a fork of swenyai/marketplace`);
         return { type, id, name: id, outputPath: destDir };
     }
 }
+/**
+ * Recursively copy a skill source directory to its destination (Fix #17).
+ *
+ * Previously a flat `fs.readdirSync` + `fs.copyFileSync` loop: skills with
+ * nested directories (scripts/, references/, assets/) either silently
+ * shipped incomplete or — more often — threw EISDIR on the first subdir.
+ *
+ * Exported for tests; node:fs cp's recursive mode preserves structure.
+ */
+export function copySkillDir(sourceDir, destDir) {
+    fs.mkdirSync(destDir, { recursive: true });
+    fs.cpSync(sourceDir, destDir, { recursive: true });
+}
 // ── Command registration ───────────────────────────────────────────────
 export function registerPublishCommand(program) {
     program

package/dist/executor.js

@@ -15,6 +15,8 @@
 import { consoleLogger } from "./types.js";
 import { resolveSources } from "./source-resolver.js";
 import { evaluateVerify } from "./verify.js";
+import { evaluateRequires } from "./requires.js";
+import { buildRetryPreamble } from "./retry.js";
 /**
  * Execute a workflow from entry to completion.
  *
@@ -96,6 +98,33 @@ export async function execute(workflow, input, options) {
             input,
             ...Object.fromEntries([...results.entries()].map(([k, v]) => [k, v.data])),
         };
+        // Pre-condition gate: evaluate `requires` against the cross-node context
+        // BEFORE invoking the LLM. Failure either marks the node failed (on_fail
+        // default) or skipped (on_fail: "skip") and skips execution entirely.
+        const requiresError = evaluateRequires(node.requires, context);
+        if (requiresError) {
+            const onFail = node.requires?.on_fail ?? "fail";
+            const result = onFail === "skip"
+                ? {
+                    status: "skipped",
+                    data: { skipped_reason: requiresError.replace(/^requires failed:/, "requires not met:") },
+                    toolCalls: [],
+                }
+                : {
+                    status: "failed",
+                    data: { error: requiresError },
+                    toolCalls: [],
+                };
+            results.set(currentId, result);
+            trace.steps.push({ node: currentId, status: result.status, iteration });
+            safeObserve(observer, { type: "node:exit", node: currentId, result }, logger);
+            logger.warn(`  requires ${onFail === "skip" ? "skipped" : "failed"}: ${requiresError}`, { node: currentId });
+            // Apply normal routing rules (dry run gate + resolveNext).
+            // TODO: dedupe with requires path — see advanceFromNode helper below
+            const next = await advanceFromNode(workflow, currentId, results, input, claude, observer, edgeCounts, logger, trace);
+            currentId = next;
+            continue;
+        }
         // Wrap tool handlers to emit events + inject context
         const trackedTools = tools.map((t) => ({
             ...t,
@@ -111,56 +140,59 @@ export async function execute(workflow, input, options) {
         const effectiveRules = assembleCascaded("rules", currentId, workflow.nodes[currentId], inputRules.length, (workflow.rules ?? []).length, resolvedSources);
         const effectiveContext = assembleCascaded("context", currentId, workflow.nodes[currentId], inputContext.length, (workflow.context ?? []).length, resolvedSources);
         const instruction = buildNodeInstruction(resolvedInstruction, effectiveRules, effectiveContext, input, skillInstructions);
-        // Run Claude on this node
-        const result = await claude.run({
-            instruction,
-            context,
-            tools: trackedTools,
-            outputSchema: node.output,
-            maxTurns: node.max_turns,
-            onProgress: (message) => {
-                safeObserve(observer, { type: "node:progress", node: currentId, message }, logger);
-            },
-        });
-        // Machine-checked post-condition. Enforced AFTER the LLM finishes so that
-        // a model claiming success cannot bypass side-effect requirements (e.g.
-        // reporting "issue created" when no `linear_create_issue` call was made).
-        // Skipped entirely when the node already failed — the node's own error is
-        // the root cause and verify would just add noise.
-        if (result.status === "success") {
+        // Run Claude on this node, with optional verify-failure retry loop.
+        let attempt = 0;
+        let result;
+        let currentInstruction = instruction;
+        const retry = node.retry;
+        while (true) {
+            result = await claude.run({
+                instruction: currentInstruction,
+                context,
+                tools: trackedTools,
+                outputSchema: node.output,
+                maxTurns: node.max_turns,
+                onProgress: (message) => {
+                    safeObserve(observer, { type: "node:progress", node: currentId, message }, logger);
+                },
+            });
+            // Retry only triggers on verify failure — bail on tool/API errors.
+            if (result.status !== "success")
+                break;
             const verifyError = evaluateVerify(node.verify, result);
-            if (verifyError) {
-                result.status = "failed";
-                result.data = { ...result.data, error: verifyError };
+            if (!verifyError)
+                break;
+            // Apply verify failure to the result.
+            result.status = "failed";
+            result.data = { ...result.data, error: verifyError };
+            if (!retry || attempt >= retry.max) {
                 logger.warn(`  verify failed: ${verifyError}`, { node: currentId });
+                break;
             }
+            // Build retry preamble + record attempt in trace.
+            trace.steps.push({ node: currentId, status: "failed", iteration, retryAttempt: attempt });
+            logger.warn(`  verify failed (attempt ${attempt + 1}/${retry.max + 1}): ${verifyError}`, { node: currentId });
+            const preamble = await buildRetryPreamble({
+                retry,
+                verifyError,
+                toolCalls: result.toolCalls,
+                nodeInstruction: resolvedInstruction,
+                claude,
+                logger,
+                context,
+            });
+            currentInstruction = `${preamble}\n\n---\n\n${instruction}`;
+            safeObserve(observer, { type: "node:retry", node: currentId, attempt: attempt + 1, reason: verifyError, preamble }, logger);
+            attempt++;
         }
         results.set(currentId, result);
-        trace.steps.push({ node: currentId, status: result.status, iteration });
+        trace.steps.push(attempt > 0
+            ? { node: currentId, status: result.status, iteration, retryAttempt: attempt }
+            : { node: currentId, status: result.status, iteration });
         safeObserve(observer, { type: "node:exit", node: currentId, result }, logger);
         logger.info(`  ✓ ${result.status}`, { node: currentId, toolCalls: result.toolCalls.length });
-        // Dry run hard gate — stop at the first conditional routing decision.
-        // Unconditional edges are analysis flow (prepare→gather→investigate);
-        // conditional edges are action decisions (investigate→create_issue/skip).
-        // Enforced in the executor so it cannot be bypassed by LLM evaluation.
-        const isDryRun = input && typeof input === "object" && input.dryRun === true;
-        if (isDryRun) {
-            const outEdges = workflow.edges.filter((e) => e.from === currentId);
-            if (outEdges.some((e) => e.when)) {
-                safeObserve(observer, { type: "route", from: currentId, to: "(end)", reason: "dry run" }, logger);
-                currentId = null;
-                continue;
-            }
-        }
-        // Resolve next node via edge conditions
-        const prevId = currentId;
-        currentId = await resolveNext(workflow, currentId, results, input, claude, observer, edgeCounts, logger);
-        // Record the routing decision in the trace
-        if (currentId) {
-            const edgeKey = `${prevId}→${currentId}`;
-            const reason = workflow.edges.find((e) => e.from === prevId && e.to === currentId)?.when ?? "only path";
-            trace.edges.push({ from: prevId, to: currentId, reason });
-        }
+        // Dry run gate + routing — shared with requires path via advanceFromNode helper.
+        currentId = await advanceFromNode(workflow, currentId, results, input, claude, observer, edgeCounts, logger, trace);
     }
     safeObserve(observer, {
         type: "workflow:end",
@@ -341,6 +373,35 @@ function resolveConfig(skills, overrides) {
     }
     return config;
 }
+/**
+ * Apply the dry-run gate and then resolve the next node via edge conditions.
+ *
+ * Used in both the normal execution path and the requires-failure path so
+ * the dry-run guard + resolveNext + trace-edge recording logic lives in one place.
+ *
+ * Returns the next node ID, or null when execution should stop.
+ */
+async function advanceFromNode(workflow, currentId, results, input, claude, observer, edgeCounts, logger, trace) {
+    // Dry run hard gate — stop at the first conditional routing decision.
+    // Unconditional edges are analysis flow (prepare→gather→investigate);
+    // conditional edges are action decisions (investigate→create_issue/skip).
+    // Enforced in the executor so it cannot be bypassed by LLM evaluation.
+    const isDryRun = input && typeof input === "object" && input.dryRun === true;
+    if (isDryRun) {
+        const outEdges = workflow.edges.filter((e) => e.from === currentId);
+        if (outEdges.some((e) => e.when)) {
+            safeObserve(observer, { type: "route", from: currentId, to: "(end)", reason: "dry run" }, logger);
+            return null;
+        }
+    }
+    const prevId = currentId;
+    const nextId = await resolveNext(workflow, currentId, results, input, claude, observer, edgeCounts, logger);
+    if (nextId) {
+        const reason = workflow.edges.find((e) => e.from === prevId && e.to === nextId)?.when ?? "only path";
+        trace.edges.push({ from: prevId, to: nextId, reason });
+    }
+    return nextId;
+}
 /**
  * Resolve which edge to follow from the current node.
  *

package/dist/loader.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Workflow loader — read, parse, validate.
+ *
+ * The canonical path for CLI flows that read a workflow off disk. Composes
+ * file I/O + YAML/JSON parse + Zod schema parse + structural validation and
+ * returns a single tagged result so callers can render errors uniformly.
+ *
+ * Use this instead of calling `parseWorkflow` / `validateWorkflow` directly
+ * so the three user-facing surfaces (`sweny workflow run`, `sweny workflow
+ * validate`, `sweny publish`) agree on what "valid" means.
+ */
+import type { Workflow } from "./types.js";
+import { type WorkflowError } from "./schema.js";
+/** Structural/schema error. `code` is present only for structural errors. */
+export interface LoaderError {
+    message: string;
+    code?: WorkflowError["code"] | "IO" | "PARSE" | "SCHEMA";
+    nodeId?: string;
+}
+export type LoaderResult = {
+    ok: true;
+    workflow: Workflow;
+} | {
+    ok: false;
+    errors: LoaderError[];
+};
+export interface LoaderOptions {
+    /** Optional set of known skill IDs for UNKNOWN_SKILL validation. */
+    knownSkills?: Set<string>;
+}
+/**
+ * Load a workflow YAML or JSON file, parse with the canonical Zod schema,
+ * and run structural validation. All three phases contribute to `errors`.
+ */
+export declare function loadAndValidateWorkflow(filePath: string, options?: LoaderOptions): LoaderResult;
+/**
+ * Validate an already-parsed workflow object (e.g. from a marketplace fetch
+ * or Studio import). Same schema + structural passes as the file loader.
+ */
+export declare function validateParsed(raw: unknown, options?: LoaderOptions): LoaderResult;

package/dist/loader.js

@@ -0,0 +1,73 @@
+/**
+ * Workflow loader — read, parse, validate.
+ *
+ * The canonical path for CLI flows that read a workflow off disk. Composes
+ * file I/O + YAML/JSON parse + Zod schema parse + structural validation and
+ * returns a single tagged result so callers can render errors uniformly.
+ *
+ * Use this instead of calling `parseWorkflow` / `validateWorkflow` directly
+ * so the three user-facing surfaces (`sweny workflow run`, `sweny workflow
+ * validate`, `sweny publish`) agree on what "valid" means.
+ */
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { parse as parseYaml } from "yaml";
+import { ZodError } from "zod";
+import { workflowZ, validateWorkflow } from "./schema.js";
+/**
+ * Load a workflow YAML or JSON file, parse with the canonical Zod schema,
+ * and run structural validation. All three phases contribute to `errors`.
+ */
+export function loadAndValidateWorkflow(filePath, options = {}) {
+    let content;
+    try {
+        content = fs.readFileSync(filePath, "utf-8");
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        return { ok: false, errors: [{ message: `Could not read "${filePath}": ${msg}`, code: "IO" }] };
+    }
+    let raw;
+    try {
+        const ext = path.extname(filePath).toLowerCase();
+        raw = ext === ".yaml" || ext === ".yml" ? parseYaml(content) : JSON.parse(content);
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        return { ok: false, errors: [{ message: `Could not parse "${filePath}": ${msg}`, code: "PARSE" }] };
+    }
+    return validateParsed(raw, options);
+}
+/**
+ * Validate an already-parsed workflow object (e.g. from a marketplace fetch
+ * or Studio import). Same schema + structural passes as the file loader.
+ */
+export function validateParsed(raw, options = {}) {
+    if (typeof raw !== "object" || raw === null || Array.isArray(raw)) {
+        const kind = raw === null ? "null" : Array.isArray(raw) ? "array" : typeof raw;
+        return { ok: false, errors: [{ message: `Expected a workflow object, got ${kind}`, code: "SCHEMA" }] };
+    }
+    let parsed;
+    try {
+        parsed = workflowZ.parse(raw);
+    }
+    catch (err) {
+        if (err instanceof ZodError) {
+            const errors = err.issues.map((iss) => ({
+                message: `${iss.path.length > 0 ? iss.path.join(".") + ": " : ""}${iss.message}`,
+                code: "SCHEMA",
+            }));
+            return { ok: false, errors };
+        }
+        const msg = err instanceof Error ? err.message : String(err);
+        return { ok: false, errors: [{ message: msg, code: "SCHEMA" }] };
+    }
+    const structural = validateWorkflow(parsed, options.knownSkills);
+    if (structural.length > 0) {
+        return {
+            ok: false,
+            errors: structural.map((e) => ({ message: e.message, code: e.code, nodeId: e.nodeId })),
+        };
+    }
+    return { ok: true, workflow: parsed };
+}

package/dist/mcp-catalog.d.ts

@@ -0,0 +1,47 @@
+/**
+ * MCP Provider Catalog — single source of truth for provider/MCP wiring.
+ *
+ * Before this catalog existed, `buildSkillMcpServers` (skill-driven) and
+ * `buildAutoMcpServers` (flag-driven, legacy triage/implement) each encoded
+ * the same transport/auth/env for every provider. Drift was inevitable.
+ *
+ * Each entry declares:
+ *   - which trigger paths (skill id, provider flag, workspace tool) wire it
+ *   - how to build the McpServerConfig from credentials
+ *   - whether the server uses stdio or http transport
+ *   - if stdio: why the `npx -y` policy exception is acceptable (Fix #18)
+ *
+ * Adding a provider is a one-place edit. A module-load assertion and a
+ * test enforce that every stdio entry declares its exception reason.
+ */
+import type { McpServerConfig } from "./types.js";
+export interface McpCatalogEntry {
+    /** Canonical server id. Used as the key in the returned `Record<string, McpServerConfig>`. */
+    id: string;
+    /** Which trigger paths wire this server. Most entries match both skill-driven and flag-driven paths. */
+    triggers: {
+        /** Skill IDs that should wire this server (skill-driven path). */
+        skill?: string[];
+        /** Matching values for `sourceControlProvider` (flag-driven path). */
+        sourceControl?: string[];
+        /** Matching values for `issueTrackerProvider` (flag-driven path). */
+        issueTracker?: string[];
+        /** Matching entries in `observabilityProviders` (flag-driven path). */
+        observability?: string[];
+        /** Matching entries in `workspaceTools` (flag-driven path). */
+        workspaceTool?: string[];
+    };
+    /** Build the MCP server config from creds. Returns undefined if required creds are missing. */
+    wire: (creds: Record<string, string>) => McpServerConfig | undefined;
+    /** Transport family. Informational + policy enforcement (Fix #18). */
+    transport: "http" | "stdio";
+    /**
+     * For stdio servers, why `npx -y` is allowed. Null forbids the exception.
+     * Http servers must set this to null (no exception needed).
+     *
+     * ARCHITECTURE.md documents the acceptable reasons (official first-party
+     * vendor server with no public HTTP endpoint, etc.).
+     */
+    npxExceptionReason: string | null;
+}
+export declare const MCP_CATALOG: readonly McpCatalogEntry[];