@sweny-ai/core 0.1.62 → 0.1.64

package/dist/cli/marketplace.js

@@ -0,0 +1,290 @@
+// packages/core/src/cli/marketplace.ts
+/**
+ * Marketplace install — fetch workflows from swenyai/workflows and
+ * adapt them to the user's .sweny.yml providers.
+ *
+ * Pure functions for fetch/mismatch/adapt; file writes delegate to
+ * helpers in ./new.ts.
+ */
+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 { 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}. See https://marketplace.sweny.ai for available workflows.`);
+        err.kind = "not-found";
+        throw err;
+    }
+    if (res.status === 403 && res.headers.get("X-RateLimit-Remaining") === "0") {
+        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() };
+}
+export async function fetchMarketplaceIndex() {
+    const url = `${MARKETPLACE_RAW_BASE}/index.json`;
+    let res;
+    try {
+        res = await fetch(url);
+    }
+    catch {
+        const err = new Error(`Could not reach github.com`);
+        err.kind = "network";
+        throw err;
+    }
+    if (res.status === 404) {
+        const err = new Error(`Marketplace index not found`);
+        err.kind = "not-found";
+        throw err;
+    }
+    if (!res.ok) {
+        const err = new Error(`Fetch failed with status ${res.status}`);
+        err.kind = "unknown";
+        throw err;
+    }
+    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;
+    }
+    return raw;
+}
+const CATEGORY_TO_CONFIG_KEY = {
+    git: "source-control-provider",
+    tasks: "issue-tracker-provider",
+    observability: "observability-provider",
+    notification: "notification-provider",
+};
+export function computeProviderMismatch(workflowSkills, fileConfig, availableSkills) {
+    const skillMap = new Map(availableSkills.map((s) => [s.id, s]));
+    const out = [];
+    for (const skillId of workflowSkills) {
+        const skill = skillMap.get(skillId);
+        if (!skill)
+            continue;
+        const configKey = CATEGORY_TO_CONFIG_KEY[skill.category];
+        if (!configKey)
+            continue;
+        const userProvider = fileConfig[configKey];
+        if (typeof userProvider !== "string")
+            continue;
+        if (userProvider === skillId)
+            continue;
+        out.push({
+            category: skill.category,
+            configKey,
+            workflowSkill: skillId,
+            userProvider,
+        });
+    }
+    return out;
+}
+export function buildAdaptPrompt(mismatches) {
+    const swaps = mismatches
+        .map((m) => `- Replace the \`${m.workflowSkill}\` skill (${m.configKey}) with \`${m.userProvider}\`, preserving the intent of each node.`)
+        .join("\n");
+    return [
+        `The target project's .sweny.yml declares different providers than this workflow uses.`,
+        `Rewrite the workflow so every node uses the target project's providers:`,
+        "",
+        swaps,
+        "",
+        `Keep node IDs, edge structure, and instruction intent. Only change skill references and any node instructions that name the old provider by name.`,
+    ].join("\n");
+}
+/**
+ * Render the workflow DAG and run an accept/refine/cancel loop.
+ * Returns the accepted workflow or null on cancel.
+ *
+ * Applies `initialRefinement` (if provided) before the first render.
+ */
+export async function adaptWorkflowInteractive(workflow, options) {
+    const { claude, skills, logger, initialRefinement } = options;
+    let current = workflow;
+    if (initialRefinement) {
+        const spinner = p.spinner();
+        spinner.start("Adapting workflow to your project…");
+        try {
+            current = await refineWorkflow(current, initialRefinement, { claude, skills, logger });
+            spinner.stop("Adapted");
+        }
+        catch (err) {
+            spinner.stop("Adaptation failed");
+            p.log.error(`  ${err instanceof Error ? err.message : String(err)}`);
+            // fall through — user sees the un-adapted workflow
+        }
+    }
+    while (true) {
+        console.log("");
+        console.log(new DagRenderer(current, { animate: false }).renderToString());
+        console.log("");
+        const action = await p.select({
+            message: "Looks good?",
+            options: [
+                { value: "accept", label: "Yes — use this workflow" },
+                { value: "refine", label: "Refine — describe what to change" },
+                { value: "cancel", label: "Cancel" },
+            ],
+        });
+        if (p.isCancel(action) || action === "cancel")
+            return null;
+        if (action === "accept")
+            return current;
+        if (action === "refine") {
+            const refinement = await p.text({
+                message: "What would you like to change?",
+                validate: (v) => (v && v.trim().length > 0 ? undefined : "Refinement is required"),
+            });
+            if (p.isCancel(refinement))
+                return null;
+            const rspin = p.spinner();
+            rspin.start("Refining…");
+            try {
+                current = await refineWorkflow(current, refinement, { claude, skills, logger });
+                rspin.stop("Refined");
+            }
+            catch (err) {
+                rspin.stop("Failed");
+                p.log.error(`  ${err instanceof Error ? err.message : String(err)}`);
+            }
+        }
+    }
+}
+/**
+ * Fetch a workflow from swenyai/workflows, 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,
+ * returns `{ installed: false, alreadyExists: true, workflowPath }` without
+ * touching the file. The caller (runNew) is responsible for prompting the user.
+ *
+ * Pre-computed provider fields (`inferredSourceControl`, `inferredIssueTracker`,
+ * `inferredObservability`) take precedence over skill-based inference when
+ * provided. Omit them to use the original skill-based fallback (backward-compat
+ * for direct callers that don't have git-remote information).
+ */
+export async function installMarketplaceWorkflow(id, options) {
+    const { cwd, availableSkills, claude, logger } = options;
+    const overwrite = options.overwrite ?? false;
+    // 1. Fetch
+    const fetched = await fetchMarketplaceWorkflow(id);
+    // 2. 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
+    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,
+                logger,
+                initialRefinement: buildAdaptPrompt(mismatches),
+            });
+            if (refined === null) {
+                // user cancelled — signal no install
+                return {
+                    installed: false,
+                    adapted: false,
+                    workflowPath: "",
+                    mismatches,
+                    addedEnvKeys: 0,
+                };
+            }
+            finalYaml = stringifyYaml(refined, { indent: 2, lineWidth: 120 });
+            adapted = true;
+        }
+        catch (err) {
+            logger.warn(`Adaptation failed, installing as-is: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }
+    else if (mismatches.length > 0) {
+        const swapDesc = mismatches.map((m) => `${m.workflowSkill} → ${m.userProvider}`).join(", ");
+        logger.warn(`Workflow uses providers different from your .sweny.yml (${swapDesc}). ` +
+            `Install as-is and edit manually, or set ANTHROPIC_API_KEY and re-run to adapt automatically.`);
+    }
+    // 4. Infer providers for fresh-project .sweny.yml.
+    // Pre-computed values from the caller (git-remote-based) take precedence;
+    // fall back to skill-based inference for backward-compat with direct callers.
+    const finalSkills = extractSkillsFromYaml(finalYaml);
+    const sourceControl = options.inferredSourceControl !== undefined
+        ? options.inferredSourceControl
+        : finalSkills.includes("gitlab")
+            ? "gitlab"
+            : "github";
+    const issueTracker = options.inferredIssueTracker !== undefined
+        ? options.inferredIssueTracker
+        : finalSkills.includes("linear")
+            ? "linear"
+            : finalSkills.includes("jira")
+                ? "jira"
+                : "github-issues";
+    const observability = options.inferredObservability !== undefined
+        ? options.inferredObservability
+        : finalSkills.includes("datadog")
+            ? "datadog"
+            : finalSkills.includes("sentry")
+                ? "sentry"
+                : finalSkills.includes("betterstack")
+                    ? "betterstack"
+                    : finalSkills.includes("newrelic")
+                        ? "newrelic"
+                        : null;
+    writeSwenyYmlIfMissing(cwd, sourceControl, observability, issueTracker);
+    // 5. Credentials
+    const creds = collectCredentialsForSkills(finalSkills, availableSkills);
+    const addedEnvKeys = appendMissingEnvKeys(cwd, creds);
+    // 6. Workflow file — respect the overwrite flag.
+    const write = writeWorkflowFile(cwd, id, finalYaml, { overwrite });
+    if (!write.written) {
+        // File exists and overwrite was false — signal the caller.
+        return {
+            installed: false,
+            adapted,
+            workflowPath: write.path,
+            mismatches,
+            addedEnvKeys,
+            alreadyExists: true,
+        };
+    }
+    return {
+        installed: true,
+        adapted,
+        workflowPath: write.path,
+        mismatches,
+        addedEnvKeys,
+    };
+}

package/dist/cli/marketplace.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/cli/marketplace.test.js

@@ -0,0 +1,355 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import * as os from "node:os";
+import { fetchMarketplaceWorkflow, fetchMarketplaceIndex, computeProviderMismatch, buildAdaptPrompt, adaptWorkflowInteractive, installMarketplaceWorkflow, MARKETPLACE_RAW_BASE, } from "./marketplace.js";
+vi.mock("@clack/prompts", () => ({
+    select: vi.fn(),
+    text: vi.fn(),
+    spinner: () => ({ start: vi.fn(), stop: vi.fn() }),
+    log: { message: vi.fn(), error: vi.fn() },
+    isCancel: (v) => v === Symbol.for("cancel"),
+}));
+vi.mock("../workflow-builder.js", () => ({
+    refineWorkflow: vi.fn(),
+}));
+describe("fetchMarketplaceWorkflow", () => {
+    let fetchSpy;
+    beforeEach(() => {
+        fetchSpy = vi.spyOn(globalThis, "fetch").mockImplementation(async () => {
+            return new Response("id: pr-review\nname: PR Review\n", { status: 200 });
+        });
+    });
+    afterEach(() => fetchSpy.mockRestore());
+    it("fetches workflow YAML from raw GitHub", async () => {
+        const result = await fetchMarketplaceWorkflow("pr-review");
+        expect(result.id).toBe("pr-review");
+        expect(result.yaml).toContain("id: pr-review");
+        expect(fetchSpy).toHaveBeenCalledWith(`${MARKETPLACE_RAW_BASE}/workflows/pr-review.yml`);
+    });
+});
+describe("fetchMarketplaceWorkflow errors", () => {
+    let fetchSpy;
+    afterEach(() => fetchSpy?.mockRestore());
+    it("throws not-found on 404", async () => {
+        fetchSpy = vi.spyOn(globalThis, "fetch").mockImplementation(async () => new Response("", { status: 404 }));
+        await expect(fetchMarketplaceWorkflow("missing")).rejects.toMatchObject({
+            kind: "not-found",
+            message: expect.stringContaining("missing"),
+        });
+    });
+    it("throws rate-limit on 403 with X-RateLimit-Remaining: 0", async () => {
+        fetchSpy = vi.spyOn(globalThis, "fetch").mockImplementation(async () => new Response("", {
+            status: 403,
+            headers: { "X-RateLimit-Remaining": "0", "X-RateLimit-Reset": "1234567890" },
+        }));
+        await expect(fetchMarketplaceWorkflow("pr-review")).rejects.toMatchObject({
+            kind: "rate-limit",
+            retryAfter: 1234567890,
+        });
+    });
+    it("throws network error when fetch rejects", async () => {
+        fetchSpy = vi.spyOn(globalThis, "fetch").mockImplementation(async () => {
+            throw new TypeError("fetch failed");
+        });
+        await expect(fetchMarketplaceWorkflow("pr-review")).rejects.toMatchObject({
+            kind: "network",
+        });
+    });
+});
+describe("fetchMarketplaceIndex", () => {
+    afterEach(() => vi.restoreAllMocks());
+    it("fetches and parses index.json", async () => {
+        const body = JSON.stringify([
+            { id: "pr-review", name: "PR Review", description: "Reviews PRs", skills: ["github"] },
+            { id: "issue-triage", name: "Issue Triage", description: "Triages issues", skills: ["github"] },
+        ]);
+        vi.spyOn(globalThis, "fetch").mockImplementation(async () => new Response(body, { status: 200 }));
+        const entries = await fetchMarketplaceIndex();
+        expect(entries).toHaveLength(2);
+        expect(entries[0]).toMatchObject({ id: "pr-review", name: "PR Review" });
+    });
+    it("throws not-found when index.json is missing", async () => {
+        vi.spyOn(globalThis, "fetch").mockImplementation(async () => new Response("", { status: 404 }));
+        await expect(fetchMarketplaceIndex()).rejects.toMatchObject({ kind: "not-found" });
+    });
+});
+const testSkills = [
+    { id: "linear", name: "Linear", description: "", category: "tasks", config: {}, tools: [] },
+    {
+        id: "github-issues",
+        name: "GitHub Issues",
+        description: "",
+        category: "tasks",
+        config: {},
+        tools: [],
+    },
+    { id: "github", name: "GitHub", description: "", category: "git", config: {}, tools: [] },
+    {
+        id: "datadog",
+        name: "Datadog",
+        description: "",
+        category: "observability",
+        config: {},
+        tools: [],
+    },
+    { id: "sentry", name: "Sentry", description: "", category: "observability", config: {}, tools: [] },
+];
+describe("computeProviderMismatch", () => {
+    it("returns empty array when all workflow skills match config", () => {
+        const mismatches = computeProviderMismatch(["github", "github-issues"], { "source-control-provider": "github", "issue-tracker-provider": "github-issues" }, testSkills);
+        expect(mismatches).toEqual([]);
+    });
+    it("detects tasks mismatch (workflow=linear, config=github-issues)", () => {
+        const mismatches = computeProviderMismatch(["linear"], { "issue-tracker-provider": "github-issues" }, testSkills);
+        expect(mismatches).toEqual([
+            {
+                category: "tasks",
+                configKey: "issue-tracker-provider",
+                workflowSkill: "linear",
+                userProvider: "github-issues",
+            },
+        ]);
+    });
+    it("detects observability mismatch and ignores general-category skills", () => {
+        const mismatches = computeProviderMismatch(["datadog"], { "observability-provider": "sentry" }, testSkills);
+        expect(mismatches).toEqual([
+            {
+                category: "observability",
+                configKey: "observability-provider",
+                workflowSkill: "datadog",
+                userProvider: "sentry",
+            },
+        ]);
+    });
+    it("skips mismatch when the user has no provider set for that role", () => {
+        const mismatches = computeProviderMismatch(["linear"], {}, testSkills);
+        expect(mismatches).toEqual([]);
+    });
+    it("ignores workflow skills not in the available skill registry", () => {
+        const mismatches = computeProviderMismatch(["unknown-skill"], { "issue-tracker-provider": "github-issues" }, testSkills);
+        expect(mismatches).toEqual([]);
+    });
+});
+describe("buildAdaptPrompt", () => {
+    it("describes single mismatch", () => {
+        const prompt = buildAdaptPrompt([
+            {
+                category: "tasks",
+                configKey: "issue-tracker-provider",
+                workflowSkill: "linear",
+                userProvider: "github-issues",
+            },
+        ]);
+        expect(prompt).toContain("linear");
+        expect(prompt).toContain("github-issues");
+        expect(prompt).toContain("issue-tracker");
+        expect(prompt.toLowerCase()).toContain("rewrite");
+    });
+    it("describes multiple mismatches", () => {
+        const prompt = buildAdaptPrompt([
+            {
+                category: "tasks",
+                configKey: "issue-tracker-provider",
+                workflowSkill: "linear",
+                userProvider: "github-issues",
+            },
+            {
+                category: "observability",
+                configKey: "observability-provider",
+                workflowSkill: "datadog",
+                userProvider: "sentry",
+            },
+        ]);
+        expect(prompt).toContain("linear");
+        expect(prompt).toContain("datadog");
+        expect(prompt).toContain("sentry");
+    });
+});
+describe("adaptWorkflowInteractive", () => {
+    beforeEach(() => vi.clearAllMocks());
+    const sampleWorkflow = {
+        id: "pr-review",
+        name: "PR Review",
+        description: "",
+        entry: "start",
+        nodes: { start: { name: "Start", instruction: "x", skills: [] } },
+        edges: [],
+    };
+    it("returns the workflow when user accepts on first render", async () => {
+        const p = await import("@clack/prompts");
+        p.select.mockResolvedValueOnce("accept");
+        const claudeStub = { run: vi.fn() };
+        const result = await adaptWorkflowInteractive(sampleWorkflow, {
+            claude: claudeStub,
+            skills: [],
+            logger: { debug: () => { }, info: () => { }, warn: () => { }, error: () => { } },
+        });
+        expect(result).toEqual(sampleWorkflow);
+    });
+    it("returns null when user cancels", async () => {
+        const p = await import("@clack/prompts");
+        p.select.mockResolvedValueOnce("cancel");
+        const claudeStub = { run: vi.fn() };
+        const result = await adaptWorkflowInteractive(sampleWorkflow, {
+            claude: claudeStub,
+            skills: [],
+            logger: { debug: () => { }, info: () => { }, warn: () => { }, error: () => { } },
+        });
+        expect(result).toBeNull();
+    });
+    it("calls refineWorkflow when user picks 'refine'", async () => {
+        const p = await import("@clack/prompts");
+        const wb = await import("../workflow-builder.js");
+        p.select.mockResolvedValueOnce("refine").mockResolvedValueOnce("accept");
+        p.text.mockResolvedValueOnce("make it better");
+        wb.refineWorkflow.mockResolvedValueOnce(sampleWorkflow);
+        const claudeStub = { run: vi.fn() };
+        const result = await adaptWorkflowInteractive(sampleWorkflow, {
+            claude: claudeStub,
+            skills: [],
+            logger: { debug: () => { }, info: () => { }, warn: () => { }, error: () => { } },
+        });
+        expect(wb.refineWorkflow).toHaveBeenCalledWith(sampleWorkflow, "make it better", expect.any(Object));
+        expect(result).toEqual(sampleWorkflow);
+    });
+});
+describe("installMarketplaceWorkflow", () => {
+    const tmpDirs = [];
+    afterEach(() => {
+        for (const d of tmpDirs)
+            fs.rmSync(d, { recursive: true, force: true });
+        tmpDirs.length = 0;
+        vi.restoreAllMocks();
+    });
+    function tmp() {
+        const dir = fs.mkdtempSync(path.join(os.tmpdir(), "sweny-install-"));
+        tmpDirs.push(dir);
+        return dir;
+    }
+    const sampleYaml = "id: pr-review\nname: PR Review\ndescription: Review PRs\nentry: start\n" +
+        "nodes:\n  start:\n    name: Start\n    instruction: hi\n    skills: [github]\nedges: []\n";
+    it("installs workflow as-is when no mismatch and no .sweny.yml", async () => {
+        const cwd = tmp();
+        vi.spyOn(globalThis, "fetch").mockImplementation(async () => new Response(sampleYaml, { status: 200 }));
+        const result = await installMarketplaceWorkflow("pr-review", {
+            cwd,
+            availableSkills: testSkills,
+            claude: null,
+            logger: { debug: () => { }, info: () => { }, warn: () => { }, error: () => { } },
+        });
+        expect(result.installed).toBe(true);
+        expect(result.adapted).toBe(false);
+        expect(fs.existsSync(path.join(cwd, ".sweny.yml"))).toBe(true);
+        expect(fs.existsSync(path.join(cwd, ".sweny", "workflows", "pr-review.yml"))).toBe(true);
+    });
+    it("warns and installs as-is when mismatch detected but no agent", async () => {
+        const cwd = tmp();
+        fs.writeFileSync(path.join(cwd, ".sweny.yml"), "issue-tracker-provider: github-issues\n");
+        const yamlWithLinear = sampleYaml.replace("[github]", "[linear]");
+        vi.spyOn(globalThis, "fetch").mockImplementation(async () => new Response(yamlWithLinear, { status: 200 }));
+        const warnings = [];
+        const result = await installMarketplaceWorkflow("pr-review", {
+            cwd,
+            availableSkills: testSkills,
+            claude: null,
+            logger: {
+                debug: () => { },
+                info: () => { },
+                warn: (m) => warnings.push(m),
+                error: () => { },
+            },
+        });
+        expect(result.installed).toBe(true);
+        expect(result.adapted).toBe(false);
+        expect(result.mismatches).toHaveLength(1);
+        expect(warnings.some((w) => w.includes("linear"))).toBe(true);
+    });
+    it("throws with not-found kind when workflow missing", async () => {
+        const cwd = tmp();
+        vi.spyOn(globalThis, "fetch").mockImplementation(async () => new Response("", { status: 404 }));
+        await expect(installMarketplaceWorkflow("nope", {
+            cwd,
+            availableSkills: testSkills,
+            claude: null,
+            logger: { debug: () => { }, info: () => { }, warn: () => { }, error: () => { } },
+        })).rejects.toMatchObject({ kind: "not-found" });
+    });
+    // ── I1: pre-computed provider inference ────────────────────────────────
+    it("uses inferredSourceControl instead of skill-based inference for .sweny.yml", async () => {
+        // Workflow references github skill, but caller says the remote is gitlab.
+        // The written .sweny.yml must say gitlab, not github.
+        const cwd = tmp();
+        vi.spyOn(globalThis, "fetch").mockImplementation(async () => new Response(sampleYaml, { status: 200 }));
+        await installMarketplaceWorkflow("pr-review", {
+            cwd,
+            availableSkills: testSkills,
+            claude: null,
+            logger: { debug: () => { }, info: () => { }, warn: () => { }, error: () => { } },
+            inferredSourceControl: "gitlab",
+            inferredIssueTracker: "github-issues",
+            inferredObservability: null,
+        });
+        const swenyYml = fs.readFileSync(path.join(cwd, ".sweny.yml"), "utf-8");
+        expect(swenyYml).toContain("source-control-provider: gitlab");
+        // skill-based fallback would have written "github" — verify it did NOT
+        expect(swenyYml).not.toContain("source-control-provider: github");
+    });
+    it("falls back to skill-based inference when inferredSourceControl is absent", async () => {
+        // Workflow references github skill, no pre-computed values → should infer github
+        const cwd = tmp();
+        vi.spyOn(globalThis, "fetch").mockImplementation(async () => new Response(sampleYaml, { status: 200 }));
+        await installMarketplaceWorkflow("pr-review", {
+            cwd,
+            availableSkills: testSkills,
+            claude: null,
+            logger: { debug: () => { }, info: () => { }, warn: () => { }, error: () => { } },
+        });
+        const swenyYml = fs.readFileSync(path.join(cwd, ".sweny.yml"), "utf-8");
+        expect(swenyYml).toContain("source-control-provider: github");
+    });
+    // ── I2: overwrite protection ────────────────────────────────────────────
+    it("returns alreadyExists=true without overwriting when overwrite is false (default)", async () => {
+        const cwd = tmp();
+        // Pre-create the workflow file with distinct content
+        const wfDir = path.join(cwd, ".sweny", "workflows");
+        fs.mkdirSync(wfDir, { recursive: true });
+        const wfPath = path.join(wfDir, "pr-review.yml");
+        fs.writeFileSync(wfPath, "# original content\n", "utf-8");
+        vi.spyOn(globalThis, "fetch").mockImplementation(async () => new Response(sampleYaml, { status: 200 }));
+        const result = await installMarketplaceWorkflow("pr-review", {
+            cwd,
+            availableSkills: testSkills,
+            claude: null,
+            logger: { debug: () => { }, info: () => { }, warn: () => { }, error: () => { } },
+            // overwrite: false is the default — omitting it intentionally
+        });
+        expect(result.installed).toBe(false);
+        expect(result.alreadyExists).toBe(true);
+        expect(result.workflowPath).toBe(wfPath);
+        // File must be unchanged
+        expect(fs.readFileSync(wfPath, "utf-8")).toBe("# original content\n");
+    });
+    it("overwrites existing workflow file when overwrite is true", async () => {
+        const cwd = tmp();
+        // Pre-create the workflow file with stale content
+        const wfDir = path.join(cwd, ".sweny", "workflows");
+        fs.mkdirSync(wfDir, { recursive: true });
+        const wfPath = path.join(wfDir, "pr-review.yml");
+        fs.writeFileSync(wfPath, "# stale content\n", "utf-8");
+        vi.spyOn(globalThis, "fetch").mockImplementation(async () => new Response(sampleYaml, { status: 200 }));
+        const result = await installMarketplaceWorkflow("pr-review", {
+            cwd,
+            availableSkills: testSkills,
+            claude: null,
+            logger: { debug: () => { }, info: () => { }, warn: () => { }, error: () => { } },
+            overwrite: true,
+        });
+        expect(result.installed).toBe(true);
+        expect(result.alreadyExists).toBeUndefined();
+        // File must contain the new content
+        const written = fs.readFileSync(wfPath, "utf-8");
+        expect(written).toContain("PR Review");
+        expect(written).not.toContain("stale content");
+    });
+});