@sweny-ai/core 0.1.184 → 0.1.186

package/dist/cli/comment-output.d.ts

@@ -4,7 +4,8 @@
  * `--comment-file`, and any runner (the GitHub Action, GitLab, a script) posts it.
  *
  * METADATA ONLY. Node names, statuses, counts, and durations. Never prompts,
- * tool inputs, node outputs, errors, or model prose.
+ * tool inputs, node outputs, errors, or model prose. The optional "since last
+ * run" line carries counts of added and resolved answers, never their text.
  */
 import type { ExecutionTrace, NodeResult, Workflow } from "../types.js";
 import { type RunSummary } from "./run-output.js";
@@ -15,6 +16,8 @@ export interface RunCommentOptions {
     durationsMs?: Record<string, number>;
     /** Run id; the ticket shows its short hash. */
     runId?: string;
+    /** Pre-rendered "since last run" markdown line (run-answers.ts formatSinceLastMarkdown): counts only. */
+    sinceLast?: string | null;
 }
 /** Hidden marker the poster searches for to update the comment in place. */
 export declare function runCommentMarker(workflowId: string): string;

package/dist/cli/comment-output.js

@@ -4,7 +4,8 @@
  * `--comment-file`, and any runner (the GitHub Action, GitLab, a script) posts it.
  *
  * METADATA ONLY. Node names, statuses, counts, and durations. Never prompts,
- * tool inputs, node outputs, errors, or model prose.
+ * tool inputs, node outputs, errors, or model prose. The optional "since last
+ * run" line carries counts of added and resolved answers, never their text.
  */
 import { workspaceRoot, writeFileNoFollow } from "../safe-file.js";
 import { toMermaidBlock } from "../mermaid.js";
@@ -40,6 +41,7 @@ export function formatRunComment(workflow, results, summary, opts = {}) {
         "",
         ticketBlock(workflow, summary, opts.runId),
         "",
+        ...(opts.sinceLast ? [opts.sinceLast, ""] : []),
         toMermaidBlock(workflow, { state, trace: opts.trace }),
         "",
         "<details>",

package/dist/cli/main.js

@@ -35,6 +35,7 @@ import { nonInteractiveUsage, runNew } from "./new.js";
 import { formatFinalMarkdown, formatFinalOutput, formatSavedOutputLine, resolveFinalOutput, shouldPrintFinalOutput, writeFinalOutput, } from "./final-output.js";
 import { buildRunRecord, createNodeTimer, historyDisabled, newRunId, recordRun } from "./run-history.js";
 import { registerRunsCommand } from "./runs.js";
+import { formatSinceLast, formatSinceLastMarkdown, recordRunAnswers } from "./run-answers.js";
 import { registerTryCommand } from "./try.js";
 import { JournalLockedError, JournalMismatchError, RunJournal, runSecretValues } from "../journal.js";
 import { journalDisabled, prepareResume, RESUME_SHARED_RUN_FLAGS, WORKFLOW_RESUME_OPTIONS, } from "./resume.js";
@@ -1053,6 +1054,16 @@ resume) {
         const wfHasFailed = [...results.values()].some((r) => r.status === "failed");
         journal?.end(wfHasFailed ? "failed" : "success");
         recordHistory(results, trace, false);
+        // What the run answered (declared output fields, redacted), beside the history record, then a
+        // comparison with the previous run of this workflow for the "since last run" line.
+        const sinceLast = historyDisabled(options.history, fileConfig["history"])
+            ? null
+            : recordRunAnswers({
+                runId,
+                workflow,
+                results,
+                secrets: runSecretValues([...skills.values(), ...builtinSkills], process.env),
+            });
         // Close the cloud lifecycle session BEFORE the JSON early-exit so
         // every workflow run reports a terminal status, regardless of how
         // the CLI returns (json, mermaid, or normal stdout).
@@ -1069,6 +1080,7 @@ resume) {
                 trace,
                 durationsMs: Object.fromEntries(nodeTimer.durations),
                 runId,
+                sinceLast: sinceLast ? formatSinceLastMarkdown(sinceLast) : null,
             });
         }
         if (isJson) {
@@ -1094,7 +1106,7 @@ resume) {
         // Run receipt (metadata only) + optional $GITHUB_STEP_SUMMARY.
         runLogger.flush();
         const receipt = summarizeRun(results, wfDurationMs, false, trace);
-        writeStepSummary(workflow, results, receipt, trace);
+        writeStepSummary(workflow, results, receipt, trace, process.env, sinceLast ? formatSinceLastMarkdown(sinceLast) : null);
         // The answer, above the receipt: the terminal node's result, or the failed node's error.
         // Also saved to .sweny/runs/<id>/output.md (local only; --no-history skips the file).
         // Redacted with the journal's redactor; in CI printed only with --show-output.
@@ -1117,12 +1129,16 @@ resume) {
         // The receipt: a ticket on a TTY, one plain line in CI and pipes.
         if (wfHasFailed) {
             await writeReceipt(receipt, { workflow: workflow.id, runId, stream: process.stderr });
+            if (sinceLast)
+                console.error(createPaint(colorEnabled(process.stderr)).muted(`  ${formatSinceLast(sinceLast)}`));
             if (journal?.active)
                 console.error(c.subtle(`  resume with: sweny workflow resume ${runId}\n`));
             process.exit(1);
             return;
         }
         await writeReceipt(receipt, { workflow: workflow.id, runId, stream: process.stdout });
+        if (sinceLast)
+            console.log(createPaint(colorEnabled(process.stdout)).muted(`  ${formatSinceLast(sinceLast)}`));
         process.exit(0);
     }
     catch (err) {

package/dist/cli/marketplace.d.ts

@@ -1,5 +1,5 @@
 /**
- * Marketplace install — fetch workflows from swenyai/workflows and
+ * Marketplace install — fetch workflows from swenyai/marketplace and
  * adapt them to the user's .sweny.yml providers.
  *
  * Pure functions for fetch/mismatch/adapt; file writes delegate to
@@ -7,8 +7,13 @@
  */
 import type { Skill, SkillCategory, Workflow, Claude, Logger } from "../types.js";
 import type { FileConfig } from "./config-file.js";
-export declare const MARKETPLACE_REPO = "swenyai/workflows";
-export declare const MARKETPLACE_RAW_BASE = "https://raw.githubusercontent.com/swenyai/workflows/main";
+export declare const MARKETPLACE_REPO = "swenyai/marketplace";
+export declare const MARKETPLACE_BRANCH = "main";
+export declare const MARKETPLACE_RAW_BASE = "https://raw.githubusercontent.com/swenyai/marketplace/main";
+/** One recursive tree call lists every workflow file; the marketplace publishes no index of its own. */
+export declare const MARKETPLACE_TREE_URL = "https://api.github.com/repos/swenyai/marketplace/git/trees/main?recursive=1";
+/** Directories under `workflows/` in the marketplace repo, in lookup order (official wins on an id clash). */
+export declare const MARKETPLACE_SOURCES: readonly ["official", "community"];
 export interface MarketplaceEntry {
     id: string;
     name: string;
@@ -23,7 +28,13 @@ export interface FetchedWorkflow {
     id: string;
     yaml: string;
 }
+/** Fetch `workflows/official/<id>.yml`, then `workflows/community/<id>.yml`, from swenyai/marketplace. */
 export declare function fetchMarketplaceWorkflow(id: string): Promise<FetchedWorkflow>;
+/**
+ * Build the browse list from the marketplace repo itself: one GitHub tree call
+ * to list `workflows/{official,community}/*.yml`, then each file's name,
+ * description and skills. Files that fail to fetch or parse are skipped.
+ */
 export declare function fetchMarketplaceIndex(opts?: {
     timeoutMs?: number;
 }): Promise<MarketplaceEntry[]>;
@@ -90,7 +101,7 @@ export interface InstallResult {
     alreadyExists?: boolean;
 }
 /**
- * Fetch a workflow from swenyai/workflows, adapt if provider mismatch is detected
+ * Fetch a workflow from swenyai/marketplace, adapt if provider mismatch is detected
  * AND an agent is available, then write files idempotently.
  *
  * When `overwrite` is false (default) and the workflow file already exists,

package/dist/cli/marketplace.js

@@ -1,6 +1,6 @@
 // packages/core/src/cli/marketplace.ts
 /**
- * Marketplace install — fetch workflows from swenyai/workflows and
+ * Marketplace install — fetch workflows from swenyai/marketplace and
  * adapt them to the user's .sweny.yml providers.
  *
  * Pure functions for fetch/mismatch/adapt; file writes delegate to
@@ -13,67 +13,109 @@ import { DagRenderer } from "./renderer.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";
-export const MARKETPLACE_RAW_BASE = `https://raw.githubusercontent.com/${MARKETPLACE_REPO}/main`;
-export async function fetchMarketplaceWorkflow(id) {
-    const url = `${MARKETPLACE_RAW_BASE}/workflows/${id}.yml`;
-    let res;
-    try {
-        res = await fetch(url);
-    }
-    catch {
-        const err = new Error(`Could not reach github.com - check your connection`);
-        err.kind = "network";
-        throw err;
-    }
-    if (res.status === 404) {
-        const err = new Error(`Workflow "${id}" not found in ${MARKETPLACE_REPO}.`);
-        err.kind = "not-found";
-        throw err;
-    }
+export const MARKETPLACE_REPO = "swenyai/marketplace";
+export const MARKETPLACE_BRANCH = "main";
+export const MARKETPLACE_RAW_BASE = `https://raw.githubusercontent.com/${MARKETPLACE_REPO}/${MARKETPLACE_BRANCH}`;
+/** One recursive tree call lists every workflow file; the marketplace publishes no index of its own. */
+export const MARKETPLACE_TREE_URL = `https://api.github.com/repos/${MARKETPLACE_REPO}/git/trees/${MARKETPLACE_BRANCH}?recursive=1`;
+/** Directories under `workflows/` in the marketplace repo, in lookup order (official wins on an id clash). */
+export const MARKETPLACE_SOURCES = ["official", "community"];
+const WORKFLOW_ID_RE = /^[A-Za-z0-9][A-Za-z0-9_-]*$/;
+const WORKFLOW_PATH_RE = new RegExp(`^workflows/(${MARKETPLACE_SOURCES.join("|")})/([A-Za-z0-9][A-Za-z0-9_-]*)\\.yml$`);
+function fetchError(kind, message) {
+    const err = new Error(message);
+    err.kind = kind;
+    return err;
+}
+/** Throw a typed FetchError for any non-OK response (404 is left to the caller). */
+function assertOk(res) {
+    if (res.ok)
+        return;
     if (res.status === 403 && res.headers.get("X-RateLimit-Remaining") === "0") {
+        const err = fetchError("rate-limit", `GitHub rate limit hit. Set GITHUB_TOKEN to raise the limit, or retry later.`);
         const reset = res.headers.get("X-RateLimit-Reset");
-        const err = new Error(`GitHub rate limit hit. Set GITHUB_TOKEN to raise the limit, or retry later.`);
-        err.kind = "rate-limit";
         if (reset)
             err.retryAfter = parseInt(reset, 10);
         throw err;
     }
-    if (!res.ok) {
-        const err = new Error(`Fetch failed with status ${res.status}`);
-        err.kind = "unknown";
-        throw err;
-    }
-    return { id, yaml: await res.text() };
+    throw fetchError("unknown", `Fetch failed with status ${res.status}`);
 }
-export async function fetchMarketplaceIndex(opts = {}) {
-    const url = `${MARKETPLACE_RAW_BASE}/index.json`;
-    let res;
+async function httpGet(url, init) {
     try {
-        res = await fetch(url, opts.timeoutMs ? { signal: AbortSignal.timeout(opts.timeoutMs) } : undefined);
+        return await (init ? fetch(url, init) : fetch(url));
     }
     catch {
-        const err = new Error(`Could not reach github.com`);
-        err.kind = "network";
-        throw err;
+        throw fetchError("network", `Could not reach github.com - check your connection`);
     }
-    if (res.status === 404) {
-        const err = new Error(`Marketplace index not found`);
-        err.kind = "not-found";
-        throw err;
+}
+/** Fetch `workflows/official/<id>.yml`, then `workflows/community/<id>.yml`, from swenyai/marketplace. */
+export async function fetchMarketplaceWorkflow(id) {
+    if (!WORKFLOW_ID_RE.test(id)) {
+        throw fetchError("not-found", `Workflow "${id}" not found in ${MARKETPLACE_REPO}.`);
     }
-    if (!res.ok) {
-        const err = new Error(`Fetch failed with status ${res.status}`);
-        err.kind = "unknown";
-        throw err;
+    for (const source of MARKETPLACE_SOURCES) {
+        const res = await httpGet(`${MARKETPLACE_RAW_BASE}/workflows/${source}/${id}.yml`);
+        if (res.status === 404)
+            continue;
+        assertOk(res);
+        return { id, yaml: await res.text() };
     }
-    const raw = (await res.json());
-    if (!Array.isArray(raw)) {
-        const err = new Error(`Marketplace index is not an array`);
-        err.kind = "bad-yaml";
-        throw err;
+    throw fetchError("not-found", `Workflow "${id}" not found in ${MARKETPLACE_REPO}.`);
+}
+/**
+ * Build the browse list from the marketplace repo itself: one GitHub tree call
+ * to list `workflows/{official,community}/*.yml`, then each file's name,
+ * description and skills. Files that fail to fetch or parse are skipped.
+ */
+export async function fetchMarketplaceIndex(opts = {}) {
+    const signal = opts.timeoutMs ? AbortSignal.timeout(opts.timeoutMs) : undefined;
+    const headers = { Accept: "application/vnd.github+json" };
+    if (process.env.GITHUB_TOKEN)
+        headers.Authorization = `Bearer ${process.env.GITHUB_TOKEN}`;
+    const treeRes = await httpGet(MARKETPLACE_TREE_URL, { headers, ...(signal ? { signal } : {}) });
+    if (treeRes.status === 404)
+        throw fetchError("not-found", `Marketplace repo ${MARKETPLACE_REPO} not found`);
+    assertOk(treeRes);
+    const body = (await treeRes.json());
+    if (!body || !Array.isArray(body.tree)) {
+        throw fetchError("bad-yaml", `Marketplace tree listing is malformed`);
+    }
+    const found = [];
+    const seen = new Set();
+    for (const item of body.tree) {
+        if (item.type !== "blob" || typeof item.path !== "string")
+            continue;
+        const m = WORKFLOW_PATH_RE.exec(item.path);
+        if (m)
+            found.push({ source: m[1], id: m[2] });
     }
-    return raw;
+    // Official first, then community; the first source to claim an id wins.
+    found.sort((a, b) => MARKETPLACE_SOURCES.indexOf(a.source) -
+        MARKETPLACE_SOURCES.indexOf(b.source));
+    const entries = await Promise.all(found.map(async ({ source, id }) => {
+        if (seen.has(id))
+            return null;
+        seen.add(id);
+        try {
+            const res = await fetch(`${MARKETPLACE_RAW_BASE}/workflows/${source}/${id}.yml`, signal ? { signal } : undefined);
+            if (!res.ok)
+                return null;
+            const yaml = await res.text();
+            const parsed = parseYaml(yaml);
+            if (!parsed || typeof parsed !== "object")
+                return null;
+            return {
+                id,
+                name: typeof parsed.name === "string" && parsed.name ? parsed.name : id,
+                description: typeof parsed.description === "string" ? parsed.description : "",
+                skills: extractSkillsFromYaml(yaml),
+            };
+        }
+        catch {
+            return null;
+        }
+    }));
+    return entries.filter((e) => e !== null);
 }
 const CATEGORY_TO_CONFIG_KEY = {
     git: "source-control-provider",
@@ -177,7 +219,7 @@ export async function adaptWorkflowInteractive(workflow, options) {
     }
 }
 /**
- * Fetch a workflow from swenyai/workflows, adapt if provider mismatch is detected
+ * Fetch a workflow from swenyai/marketplace, adapt if provider mismatch is detected
  * AND an agent is available, then write files idempotently.
  *
  * When `overwrite` is false (default) and the workflow file already exists,

package/dist/cli/new.d.ts

@@ -145,7 +145,7 @@ export declare function nonInteractiveUsage(): string;
  * Flow:
  * 1. Detect git remote (used to infer source-control provider)
  * 2. Pick one of five branches:
- *    - `__marketplace` → browse published workflows at swenyai/workflows, then delegate to `installMarketplaceWorkflow`
+ *    - `__marketplace` → browse published workflows at swenyai/marketplace, then delegate to `installMarketplaceWorkflow`
  *    - A built-in `WORKFLOW_TEMPLATES` entry → write that workflow file
  *    - `__custom` → LLM generates a workflow from a user description
  *    - `__e2e` → delegate to the e2e browser-testing wizard in `./e2e.ts`

package/dist/cli/new.js

@@ -523,7 +523,7 @@ function cancel() {
  * Flow:
  * 1. Detect git remote (used to infer source-control provider)
  * 2. Pick one of five branches:
- *    - `__marketplace` → browse published workflows at swenyai/workflows, then delegate to `installMarketplaceWorkflow`
+ *    - `__marketplace` → browse published workflows at swenyai/marketplace, then delegate to `installMarketplaceWorkflow`
  *    - A built-in `WORKFLOW_TEMPLATES` entry → write that workflow file
  *    - `__custom` → LLM generates a workflow from a user description
  *    - `__e2e` → delegate to the e2e browser-testing wizard in `./e2e.ts`
@@ -669,7 +669,7 @@ export async function runNew(options) {
                         {
                             value: "__marketplace",
                             label: "Browse marketplace",
-                            hint: "install a published workflow from swenyai/workflows",
+                            hint: "install a published workflow from swenyai/marketplace",
                         },
                     ]
                     : []),

package/dist/cli/run-answers.d.ts

@@ -0,0 +1,162 @@
+/**
+ * What a run answered, kept so the next run can say what changed.
+ *
+ * `sweny workflow run` saves `.sweny/runs/<run-id>/answers.json` beside the
+ * output.md: each successful node's DECLARED output fields (the node's
+ * `output` schema is the contract; with no schema, only a string `summary`).
+ * Local only, mode 0600, redacted with the run journal's redactor before
+ * anything is stored. The run record itself (run-history.ts) stays metadata
+ * only; answers live in their own file so that contract is untouched.
+ *
+ * Everything under `.sweny/runs/` is writable by an agent, so it is untrusted:
+ * ids are validated against the generator's pattern before any path is built,
+ * the embedded id must match the one asked for, and the PUBLIC line (PR
+ * comment, step summary) carries only the current workflow's own id and
+ * integer counts, never text read from history.
+ *
+ * `compareAnswers` is the diff behind `sweny runs diff` and the "since last
+ * run" line. Identity rules (what counts as "the same finding") are explicit
+ * and tested; see {@link itemIdentity}.
+ */
+import type { NodeResult, Workflow } from "../types.js";
+export declare const RUN_ANSWERS_SCHEMA_VERSION = 1;
+/** Strings longer than this are cut (with an ellipsis) before they are stored. */
+export declare const ANSWER_STRING_MAX = 2000;
+export interface RunAnswers {
+    schema_version: number;
+    run_id: string;
+    workflow_id: string;
+    /** node id -> declared output fields (redacted). Only nodes that succeeded and produced a field. */
+    nodes: Record<string, Record<string, unknown>>;
+    /**
+     * Strings longer than {@link ANSWER_STRING_MAX} are cut in `nodes` (display only). This mirrors
+     * `nodes` and holds the sha256 of each cut string's FULL text, so a change past the cut still
+     * compares as changed. Absent when nothing was cut.
+     */
+    digests?: Record<string, Record<string, unknown>>;
+}
+export interface BuildRunAnswersInput {
+    runId: string;
+    workflow: Workflow;
+    results: Map<string, NodeResult>;
+    /** Secret values to redact (the same set the journal and output.md use). */
+    secrets?: string[];
+}
+/**
+ * Declared fields of each successful node, deep, redacted (values and keys). A failed or skipped
+ * node records nothing, so the diff never reads a failure as "everything resolved".
+ */
+export declare function buildRunAnswers(i: BuildRunAnswersInput): RunAnswers;
+/** Relative path: `.sweny/runs/<id>/answers.json`. */
+export declare function answersRelPath(runId: string): string;
+/** Write answers.json (mode 0600; the run dir ignores itself in git). Returns the relative path, or null. Never throws. */
+export declare function writeRunAnswers(answers: RunAnswers, cwd?: string): string | null;
+/**
+ * Read a run's answers. Null when the id is not a generated run id (checked before any path is
+ * built), the file is missing, oversized, reached through a link, corrupt, an unknown schema
+ * version, or carries a different run id than the one asked for.
+ */
+export declare function readRunAnswers(runId: string, cwd?: string): RunAnswers | null;
+/** Fields that name an item, in priority order. */
+export declare const IDENTITY_KEYS: readonly ["id", "key", "fingerprint", "title", "name"];
+/**
+ * "Is this the same finding as that one?" The rule, in order:
+ *  1. An object item is identified by the first of `id`, `key`, `fingerprint`,
+ *     `title`, `name` that holds a non-empty string or a number, normalized
+ *     (trimmed, lowercased, whitespace collapsed).
+ *  2. An object with none of those is identified by its whole content (a
+ *     short hash of its canonical JSON): any edit reads as resolved + added.
+ *  3. A plain string, number or boolean item is identified by its normalized value.
+ * Two items of one list with the same identity pair up in order.
+ */
+export declare function itemIdentity(item: unknown): string;
+export interface DiffCounts {
+    added: number;
+    resolved: number;
+    changed: number;
+    unchanged: number;
+}
+export interface DiffItem {
+    /** Normalized identity (see {@link itemIdentity}). */
+    id: string;
+    /** Human label: the raw identity value, else the first string field. */
+    label: string;
+    value: unknown;
+}
+export interface FieldChange {
+    field: string;
+    /** Absent when the field is new on this item. */
+    before?: unknown;
+    /** Absent when the field was dropped from this item. */
+    after?: unknown;
+}
+export interface ChangedItem {
+    id: string;
+    /** Label from the newer run. */
+    label: string;
+    fields: FieldChange[];
+}
+export interface CollectionEntry {
+    node: string;
+    field: string;
+    kind: "collection";
+    added: DiffItem[];
+    resolved: DiffItem[];
+    changed: ChangedItem[];
+    unchanged: number;
+}
+export interface ValueEntry {
+    node: string;
+    field: string;
+    kind: "value";
+    status: "added" | "resolved" | "changed" | "unchanged";
+    before?: unknown;
+    after?: unknown;
+}
+export type AnswerEntry = CollectionEntry | ValueEntry;
+export interface AnswerDiff {
+    available: true;
+    counts: DiffCounts;
+    entries: AnswerEntry[];
+    /** Nodes with answers in only one run: not compared, never counted as added or resolved. */
+    not_compared: Array<{
+        node: string;
+        only_in: "a" | "b";
+    }>;
+}
+export type AnswersComparison = AnswerDiff | {
+    available: false;
+    reason: "different_workflows";
+} | {
+    available: false;
+    reason: "missing_answers";
+    missing: Array<"a" | "b">;
+};
+/**
+ * Compare an older run's answers (a) with a newer one's (b), node by node and
+ * field by field. A list field (all objects, or all scalars) is diffed item by
+ * item using {@link itemIdentity}; any other field is one value. Cut strings
+ * compare by the digest of their full text.
+ */
+export declare function compareAnswers(a: RunAnswers | null, b: RunAnswers | null): AnswersComparison;
+export interface SinceLast {
+    /** The CURRENT run's own workflow id, from the loaded workflow, never from history. */
+    workflow_id: string;
+    /** The run this one was compared with. */
+    previous_run_id: string;
+    counts: DiffCounts;
+    /** Nodes with answers in only one of the two runs (failed, skipped or no output): not compared. */
+    not_compared: number;
+}
+/**
+ * Compare a recorded run with the run of the same workflow just before it. `workflowId` comes from
+ * the caller's loaded workflow; history only picks WHICH earlier run, never what is printed.
+ * Null when there is no earlier run, either run has no answers, or anything fails.
+ */
+export declare function sinceLastRun(runId: string, workflowId: string, cwd?: string): SinceLast | null;
+/** Save this run's answers, then compare with the previous run. Never throws. */
+export declare function recordRunAnswers(i: BuildRunAnswersInput, cwd?: string): SinceLast | null;
+/** Plain text, one line: for the terminal and CI logs. */
+export declare function formatSinceLast(s: SinceLast): string;
+/** Markdown, one line: for the step summary and the PR comment. */
+export declare function formatSinceLastMarkdown(s: SinceLast): string;