@sweny-ai/core 0.1.51 → 0.1.52

package/dist/cli/init.test.js

@@ -3,7 +3,7 @@ import * as fs from "node:fs";
 import * as path from "node:path";
 import * as os from "node:os";
 import { parse as parseYaml } from "yaml";
-import { collectCredentials, detectGitRemote, buildSwenyYml, buildEnvTemplate, buildActionWorkflow, PROVIDER_CREDENTIALS, } from "./init.js";
+import { collectCredentials, collectCredentialsForSkills, extractSkillsFromYaml, detectGitRemote, buildSwenyYml, buildEnvTemplate, buildActionWorkflow, PROVIDER_CREDENTIALS, SKILL_CREDENTIALS, } from "./init.js";
 // ── detectGitRemote ────────────────────────────────────────────────────
 describe("detectGitRemote", () => {
     const tmpDirs = [];
@@ -171,50 +171,17 @@ describe("PROVIDER_CREDENTIALS", () => {
 // ── buildSwenyYml ──────────────────────────────────────────────────────
 describe("buildSwenyYml", () => {
     it("includes all selected providers", () => {
-        const yml = buildSwenyYml({
-            sourceControl: "github",
-            observability: "datadog",
-            issueTracker: "linear",
-            notification: "slack",
-            githubAction: true,
-            cronExpression: "0 8 * * 1",
-        });
+        const yml = buildSwenyYml("github", "datadog", "linear");
         expect(yml).toContain("source-control-provider: github");
         expect(yml).toContain("observability-provider: datadog");
         expect(yml).toContain("issue-tracker-provider: linear");
-        expect(yml).toContain("notification-provider: slack");
     });
     it("omits observability-provider when null", () => {
-        const yml = buildSwenyYml({
-            sourceControl: "github",
-            observability: null,
-            issueTracker: "github-issues",
-            notification: "slack",
-            githubAction: false,
-            cronExpression: null,
-        });
+        const yml = buildSwenyYml("github", null, "github-issues");
         expect(yml).not.toContain("observability-provider");
     });
-    it("omits notification-provider when console (default)", () => {
-        const yml = buildSwenyYml({
-            sourceControl: "github",
-            observability: "sentry",
-            issueTracker: "github-issues",
-            notification: "console",
-            githubAction: false,
-            cronExpression: null,
-        });
-        expect(yml).not.toContain("notification-provider");
-    });
     it("includes header comments", () => {
-        const yml = buildSwenyYml({
-            sourceControl: "github",
-            observability: null,
-            issueTracker: "github-issues",
-            notification: "console",
-            githubAction: false,
-            cronExpression: null,
-        });
+        const yml = buildSwenyYml("github", null, "github-issues");
         expect(yml).toContain("# .sweny.yml");
     });
 });
@@ -407,49 +374,25 @@ describe("detectGitRemote — edge cases", () => {
 // ── buildSwenyYml: YAML validity ──────────────────────────────────────
 describe("buildSwenyYml — YAML validity", () => {
     it("generates valid YAML that can be parsed", () => {
-        const yml = buildSwenyYml({
-            sourceControl: "github",
-            observability: "datadog",
-            issueTracker: "linear",
-            notification: "slack",
-            githubAction: false,
-            cronExpression: null,
-        });
+        const yml = buildSwenyYml("github", "datadog", "linear");
         const parsed = parseYaml(yml);
         expect(parsed["source-control-provider"]).toBe("github");
         expect(parsed["observability-provider"]).toBe("datadog");
         expect(parsed["issue-tracker-provider"]).toBe("linear");
-        expect(parsed["notification-provider"]).toBe("slack");
     });
     it("generates valid YAML with minimal selections", () => {
-        const yml = buildSwenyYml({
-            sourceControl: "github",
-            observability: null,
-            issueTracker: "github-issues",
-            notification: "console",
-            githubAction: false,
-            cronExpression: null,
-        });
+        const yml = buildSwenyYml("github", null, "github-issues");
         const parsed = parseYaml(yml);
         expect(parsed["source-control-provider"]).toBe("github");
         expect(parsed["issue-tracker-provider"]).toBe("github-issues");
         expect(parsed["observability-provider"]).toBeUndefined();
-        expect(parsed["notification-provider"]).toBeUndefined();
     });
     it("uses correct key names matching config parser expectations", () => {
-        const yml = buildSwenyYml({
-            sourceControl: "gitlab",
-            observability: "sentry",
-            issueTracker: "jira",
-            notification: "teams",
-            githubAction: false,
-            cronExpression: null,
-        });
+        const yml = buildSwenyYml("gitlab", "sentry", "jira");
         // These are the exact keys the config parser reads
         expect(yml).toContain("source-control-provider:");
         expect(yml).toContain("observability-provider:");
         expect(yml).toContain("issue-tracker-provider:");
-        expect(yml).toContain("notification-provider:");
         // Must NOT contain the short form
         expect(yml).not.toMatch(/^source-control:/m);
         expect(yml).not.toMatch(/^issue-tracker:/m);
@@ -458,23 +401,13 @@ describe("buildSwenyYml — YAML validity", () => {
         const sourceControls = ["github", "gitlab"];
         const observabilities = ["datadog", "sentry", "betterstack", "newrelic", "cloudwatch", null];
         const issueTrackers = ["github-issues", "linear", "jira"];
-        const notifications = ["console", "slack", "discord", "teams", "webhook"];
         for (const sc of sourceControls) {
             for (const obs of observabilities) {
                 for (const it of issueTrackers) {
-                    for (const notif of notifications) {
-                        const yml = buildSwenyYml({
-                            sourceControl: sc,
-                            observability: obs,
-                            issueTracker: it,
-                            notification: notif,
-                            githubAction: false,
-                            cronExpression: null,
-                        });
-                        // Should not throw
-                        const parsed = parseYaml(yml);
-                        expect(parsed["source-control-provider"]).toBe(sc);
-                    }
+                    const yml = buildSwenyYml(sc, obs, it);
+                    // Should not throw
+                    const parsed = parseYaml(yml);
+                    expect(parsed["source-control-provider"]).toBe(sc);
                 }
             }
         }
@@ -662,3 +595,119 @@ describe("collectCredentials — additional cases", () => {
         }
     });
 });
+// ═══════════════════════════════════════════════════════════════════════
+// Workflow-first functions: extractSkillsFromYaml, collectCredentialsForSkills
+// ═══════════════════════════════════════════════════════════════════════
+describe("extractSkillsFromYaml", () => {
+    it("extracts skills from a single node", () => {
+        const yaml = `
+nodes:
+  review:
+    name: Code Review
+    instruction: Review the PR
+    skills: [github]
+`;
+        expect(extractSkillsFromYaml(yaml)).toEqual(["github"]);
+    });
+    it("extracts and deduplicates skills from multiple nodes", () => {
+        const yaml = `
+nodes:
+  review:
+    name: Code Review
+    skills: [github, linear]
+  scan:
+    name: Security Scan
+    skills: [github, sentry]
+`;
+        const skills = extractSkillsFromYaml(yaml);
+        expect(skills).toContain("github");
+        expect(skills).toContain("linear");
+        expect(skills).toContain("sentry");
+        expect(skills.filter((s) => s === "github")).toHaveLength(1);
+    });
+    it("returns empty array when no skills present", () => {
+        const yaml = `
+nodes:
+  review:
+    name: Code Review
+    instruction: Review the PR
+`;
+        expect(extractSkillsFromYaml(yaml)).toEqual([]);
+    });
+    it("handles skills with spaces around commas", () => {
+        const yaml = `
+nodes:
+  review:
+    skills: [github , linear , sentry]
+`;
+        const skills = extractSkillsFromYaml(yaml);
+        expect(skills).toEqual(["github", "linear", "sentry"]);
+    });
+    it("handles single-skill arrays", () => {
+        const yaml = `
+nodes:
+  review:
+    skills: [datadog]
+`;
+        expect(extractSkillsFromYaml(yaml)).toEqual(["datadog"]);
+    });
+});
+describe("collectCredentialsForSkills", () => {
+    it("always includes ANTHROPIC_API_KEY even with no skills", () => {
+        const creds = collectCredentialsForSkills([]);
+        expect(creds.map((c) => c.key)).toEqual(["ANTHROPIC_API_KEY"]);
+    });
+    it("includes credentials for specified skills", () => {
+        const creds = collectCredentialsForSkills(["github", "linear"]);
+        const keys = creds.map((c) => c.key);
+        expect(keys).toContain("ANTHROPIC_API_KEY");
+        expect(keys).toContain("GITHUB_TOKEN");
+        expect(keys).toContain("LINEAR_API_KEY");
+        expect(keys).toContain("LINEAR_TEAM_ID");
+    });
+    it("deduplicates credentials across skills", () => {
+        const creds = collectCredentialsForSkills(["github", "github"]);
+        const tokenCount = creds.filter((c) => c.key === "GITHUB_TOKEN").length;
+        expect(tokenCount).toBe(1);
+    });
+    it("skips unknown skills gracefully", () => {
+        const creds = collectCredentialsForSkills(["github", "nonexistent-skill"]);
+        const keys = creds.map((c) => c.key);
+        expect(keys).toContain("ANTHROPIC_API_KEY");
+        expect(keys).toContain("GITHUB_TOKEN");
+        expect(keys).toHaveLength(2);
+    });
+    it("ANTHROPIC_API_KEY is always first", () => {
+        const creds = collectCredentialsForSkills(["datadog", "github"]);
+        expect(creds[0].key).toBe("ANTHROPIC_API_KEY");
+    });
+});
+describe("SKILL_CREDENTIALS", () => {
+    it("has entries for all built-in skills", () => {
+        const expected = [
+            "github",
+            "gitlab",
+            "datadog",
+            "sentry",
+            "betterstack",
+            "newrelic",
+            "linear",
+            "jira",
+            "slack",
+            "discord",
+            "notification",
+        ];
+        for (const skill of expected) {
+            expect(SKILL_CREDENTIALS).toHaveProperty(skill);
+        }
+    });
+    it("every skill has valid credential entries", () => {
+        for (const [skill, creds] of Object.entries(SKILL_CREDENTIALS)) {
+            expect(Array.isArray(creds), `${skill} should have an array`).toBe(true);
+            for (const cred of creds) {
+                expect(typeof cred.key, `${skill}.${cred.key} should be a string`).toBe("string");
+                expect(cred.key, `${skill}.${cred.key} should be UPPER_SNAKE_CASE`).toMatch(/^[A-Z][A-Z0-9_]+$/);
+            }
+        }
+    });
+});

package/dist/cli/main.js

@@ -28,6 +28,7 @@ import { registerTriageCommand, registerImplementCommand, parseCliInputs, valida
 import { c, formatBanner, getStepDetails, formatStepLine, formatDagResultHuman, formatDagResultMarkdown, formatResultJson, formatValidationErrors, formatCrashError, formatCheckResults, } from "./output.js";
 import { checkProviderConnectivity } from "./check.js";
 import { registerSetupCommand } from "./setup.js";
+import { registerPublishCommand } from "./publish.js";
 // ── Stream observer (NDJSON) ────────────────────────────────────────
 /**
  * Create an observer that writes NDJSON ExecutionEvents to stdout.
@@ -100,6 +101,7 @@ program
     process.exit(hasFailure ? 1 : 0);
 });
 registerSetupCommand(program);
+registerPublishCommand(program);
 // ── Credential map builder ──────────────────────────────────────────
 // buildCredentialMap lives in ./credentials.ts so tests can import it
 // without triggering main.ts's top-level program.parse() side effect.

package/dist/cli/publish.d.ts

@@ -0,0 +1,34 @@
+/**
+ * sweny publish — Interactive CLI for publishing workflows and skills to the marketplace.
+ *
+ * Supports:
+ * - Workflow YAML files → marketplace community submission
+ * - Skill directories (SKILL.md) → marketplace skill submission
+ * - Three output modes: GitHub PR (via `gh`), copy to clipboard, save locally
+ */
+import type { Command } from "commander";
+export interface PublishResult {
+    type: "workflow" | "skill";
+    id: string;
+    name: string;
+    outputPath?: string;
+    prUrl?: string;
+}
+export declare function validateWorkflowFile(filePath: string): {
+    valid: boolean;
+    id?: string;
+    name?: string;
+    nodeCount?: number;
+    edgeCount?: number;
+    errors: string[];
+};
+export declare function validateSkillDir(dirPath: string): {
+    valid: boolean;
+    id?: string;
+    name?: string;
+    hasInstruction: boolean;
+    hasMcp: boolean;
+    errors: string[];
+};
+export declare function runPublish(): Promise<PublishResult | null>;
+export declare function registerPublishCommand(program: Command): void;

package/dist/cli/publish.js

@@ -0,0 +1,368 @@
+/**
+ * sweny publish — Interactive CLI for publishing workflows and skills to the marketplace.
+ *
+ * Supports:
+ * - Workflow YAML files → marketplace community submission
+ * - Skill directories (SKILL.md) → marketplace skill submission
+ * - Three output modes: GitHub PR (via `gh`), copy to clipboard, save locally
+ */
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { execSync } from "node:child_process";
+import * as p from "@clack/prompts";
+import chalk from "chalk";
+import { parse as parseYaml } from "yaml";
+import { parseWorkflow, validateWorkflow } from "../schema.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])?$/;
+// ── Validation helpers ─────────────────────────────────────────────────
+export function validateWorkflowFile(filePath) {
+    const errors = [];
+    if (!fs.existsSync(filePath)) {
+        return { valid: false, errors: ["File not found"] };
+    }
+    const raw = fs.readFileSync(filePath, "utf-8");
+    let parsed;
+    try {
+        parsed = parseYaml(raw);
+    }
+    catch (e) {
+        return { valid: false, errors: [`Invalid YAML: ${e instanceof Error ? e.message : e}`] };
+    }
+    try {
+        const workflow = parseWorkflow(parsed);
+        const schemaErrors = validateWorkflow(workflow);
+        if (schemaErrors.length > 0) {
+            return {
+                valid: false,
+                id: workflow.id,
+                name: workflow.name,
+                errors: schemaErrors.map((e) => e.message),
+            };
+        }
+        return {
+            valid: true,
+            id: workflow.id,
+            name: workflow.name,
+            nodeCount: Object.keys(workflow.nodes).length,
+            edgeCount: workflow.edges.length,
+            errors: [],
+        };
+    }
+    catch (e) {
+        return { valid: false, errors: [`Schema error: ${e instanceof Error ? e.message : e}`] };
+    }
+}
+export function validateSkillDir(dirPath) {
+    const errors = [];
+    const skillMdPath = path.join(dirPath, "SKILL.md");
+    if (!fs.existsSync(skillMdPath)) {
+        return { valid: false, hasInstruction: false, hasMcp: false, errors: ["SKILL.md not found in directory"] };
+    }
+    const content = fs.readFileSync(skillMdPath, "utf-8");
+    // Parse frontmatter
+    const fmMatch = content.match(/^---\n([\s\S]*?)\n---/);
+    if (!fmMatch) {
+        return { valid: false, hasInstruction: false, hasMcp: false, errors: ["No YAML frontmatter found"] };
+    }
+    let fm;
+    try {
+        fm = parseYaml(fmMatch[1]);
+    }
+    catch (e) {
+        return {
+            valid: false,
+            hasInstruction: false,
+            hasMcp: false,
+            errors: [`Invalid frontmatter YAML: ${e instanceof Error ? e.message : e}`],
+        };
+    }
+    const id = String(fm.name ?? "");
+    if (!id) {
+        errors.push("Missing 'name' field in frontmatter");
+    }
+    else if (!VALID_SKILL_ID.test(id) || id.includes("--") || id.length > 64) {
+        errors.push(`Invalid skill ID: "${id}" — must be lowercase, hyphens, no consecutive hyphens, max 64 chars`);
+    }
+    // Check directory name matches skill name
+    const dirName = path.basename(dirPath);
+    if (id && dirName !== id) {
+        errors.push(`Directory name "${dirName}" doesn't match skill name "${id}"`);
+    }
+    const body = content.slice(fmMatch[0].length).trim();
+    const hasInstruction = body.length > 0;
+    const hasMcp = fm.mcp != null;
+    if (!hasInstruction && !hasMcp) {
+        errors.push("Skill must have an instruction body or an mcp config");
+    }
+    return {
+        valid: errors.length === 0,
+        id,
+        name: id,
+        hasInstruction,
+        hasMcp,
+        errors,
+    };
+}
+// ── GitHub PR helpers ──────────────────────────────────────────────────
+function ghAvailable() {
+    try {
+        execSync("gh --version", { stdio: "pipe" });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function ghAuthenticated() {
+    try {
+        execSync("gh auth status", { stdio: "pipe" });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+// ── Cancel helper ──────────────────────────────────────────────────────
+function cancel() {
+    p.cancel("Publish cancelled.");
+    process.exit(0);
+}
+// ── Main flow ──────────────────────────────────────────────────────────
+export async function runPublish() {
+    p.intro("Publish to the SWEny Marketplace");
+    // Step 1: What to publish
+    const contentType = await p.select({
+        message: "What would you like to publish?",
+        options: [
+            { value: "workflow", label: "Workflow", hint: ".yml file" },
+            { value: "skill", label: "Skill", hint: "SKILL.md directory" },
+        ],
+    });
+    if (p.isCancel(contentType))
+        cancel();
+    if (contentType === "workflow") {
+        return await publishWorkflow();
+    }
+    else {
+        return await publishSkill();
+    }
+}
+async function publishWorkflow() {
+    // Step 2: Path to workflow
+    const filePath = await p.text({
+        message: "Path to workflow YAML file",
+        placeholder: ".sweny/workflows/my-workflow.yml",
+        validate: (v) => {
+            if (!v || v.trim().length === 0)
+                return "Path is required";
+            if (!fs.existsSync(v.trim()))
+                return "File not found";
+            return undefined;
+        },
+    });
+    if (p.isCancel(filePath))
+        cancel();
+    const absPath = path.resolve(filePath.trim());
+    const validation = validateWorkflowFile(absPath);
+    if (!validation.valid) {
+        p.log.error(`Validation failed:\n${validation.errors.map((e) => `  - ${e}`).join("\n")}`);
+        return null;
+    }
+    p.log.success(`Validated: ${chalk.cyan(validation.name)} — ${validation.nodeCount} nodes, ${validation.edgeCount} edges`);
+    // Step 3: Metadata
+    const raw = parseYaml(fs.readFileSync(absPath, "utf-8"));
+    let author = raw.author;
+    if (!author) {
+        const authorInput = await p.text({
+            message: "Author name",
+            placeholder: "your-username",
+            validate: (v) => (!v || v.trim().length === 0 ? "Author is required" : undefined),
+        });
+        if (p.isCancel(authorInput))
+            cancel();
+        author = authorInput.trim();
+    }
+    else {
+        p.log.info(`Author: ${chalk.cyan(author)}`);
+    }
+    let category = raw.category;
+    if (!category || !VALID_CATEGORIES.includes(category)) {
+        const catInput = await p.select({
+            message: "Category",
+            options: VALID_CATEGORIES.map((c) => ({ value: c, label: c })),
+        });
+        if (p.isCancel(catInput))
+            cancel();
+        category = catInput;
+    }
+    else {
+        p.log.info(`Category: ${chalk.cyan(category)}`);
+    }
+    let tags = raw.tags;
+    if (!tags || !Array.isArray(tags) || tags.length === 0) {
+        const tagsInput = await p.text({
+            message: "Tags (comma-separated)",
+            placeholder: "automation, testing, ci",
+        });
+        if (p.isCancel(tagsInput))
+            cancel();
+        tags = tagsInput
+            .split(",")
+            .map((t) => t.trim())
+            .filter(Boolean);
+    }
+    else {
+        p.log.info(`Tags: ${chalk.cyan(tags.join(", "))}`);
+    }
+    // Step 4: Output mode
+    return await selectOutputMode("workflow", validation.id, absPath, {
+        author,
+        category,
+        tags,
+    });
+}
+async function publishSkill() {
+    // Step 2: Path to skill directory
+    const dirPath = await p.text({
+        message: "Path to skill directory (containing SKILL.md)",
+        placeholder: ".sweny/skills/my-skill/",
+        validate: (v) => {
+            if (!v || v.trim().length === 0)
+                return "Path is required";
+            const resolved = path.resolve(v.trim());
+            if (!fs.existsSync(resolved))
+                return "Directory not found";
+            if (!fs.statSync(resolved).isDirectory())
+                return "Path must be a directory";
+            if (!fs.existsSync(path.join(resolved, "SKILL.md")))
+                return "SKILL.md not found in directory";
+            return undefined;
+        },
+    });
+    if (p.isCancel(dirPath))
+        cancel();
+    const absDir = path.resolve(dirPath.trim());
+    const validation = validateSkillDir(absDir);
+    if (!validation.valid) {
+        p.log.error(`Validation failed:\n${validation.errors.map((e) => `  - ${e}`).join("\n")}`);
+        return null;
+    }
+    const badges = [];
+    if (validation.hasInstruction)
+        badges.push("instruction");
+    if (validation.hasMcp)
+        badges.push("MCP");
+    p.log.success(`Validated: ${chalk.cyan(validation.id)} [${badges.join(" + ")}]`);
+    return await selectOutputMode("skill", validation.id, absDir, {});
+}
+async function selectOutputMode(type, id, sourcePath, meta) {
+    const hasGh = ghAvailable();
+    const options = [
+        ...(hasGh
+            ? [{ value: "pr", label: "Open GitHub PR", hint: "recommended — forks marketplace repo and opens a PR" }]
+            : []),
+        { value: "save", label: "Save submission file", hint: "saves to ./sweny-publish/" },
+    ];
+    const mode = await p.select({
+        message: "How would you like to publish?",
+        options,
+    });
+    if (p.isCancel(mode))
+        cancel();
+    if (mode === "pr") {
+        return await openGitHubPR(type, id, sourcePath, meta);
+    }
+    else {
+        return await saveLocally(type, id, sourcePath);
+    }
+}
+async function openGitHubPR(type, id, sourcePath, meta) {
+    if (!ghAuthenticated()) {
+        p.log.error("Not authenticated with GitHub. Run: gh auth login");
+        return null;
+    }
+    const s = p.spinner();
+    s.start("Forking marketplace repository...");
+    try {
+        // Fork the marketplace repo (idempotent — if already forked, just continues)
+        execSync("gh repo fork swenyai/marketplace --clone=false 2>&1", { stdio: "pipe" });
+        // Get the fork name
+        const forkInfo = execSync("gh api user", { stdio: "pipe", encoding: "utf-8" });
+        const username = JSON.parse(forkInfo).login;
+        const forkRepo = `${username}/marketplace`;
+        s.message("Creating branch...");
+        const branchName = `publish/${type}/${id}`;
+        // Clone to temp, create branch, add file, push, create PR
+        const tmpDir = fs.mkdtempSync(path.join(process.env.TMPDIR ?? "/tmp", "sweny-publish-"));
+        execSync(`gh repo clone ${forkRepo} ${tmpDir} -- --depth 1`, { stdio: "pipe" });
+        execSync(`git -C ${tmpDir} checkout -b ${branchName}`, { stdio: "pipe" });
+        if (type === "workflow") {
+            const dest = path.join(tmpDir, "workflows", "community", `${id}.yml`);
+            fs.copyFileSync(sourcePath, dest);
+            execSync(`git -C ${tmpDir} add workflows/community/${id}.yml`, { stdio: "pipe" });
+        }
+        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));
+            }
+            execSync(`git -C ${tmpDir} add skills/community/${id}`, { stdio: "pipe" });
+        }
+        s.message("Pushing...");
+        const commitMsg = type === "workflow" ? `feat: add ${id} workflow` : `feat: add ${id} skill`;
+        execSync(`git -C ${tmpDir} commit -m "${commitMsg}"`, { stdio: "pipe" });
+        execSync(`git -C ${tmpDir} push origin ${branchName}`, { stdio: "pipe" });
+        s.message("Creating pull request...");
+        const prBody = type === "workflow"
+            ? `## New Workflow: ${id}\n\n**Author:** ${meta.author}\n**Category:** ${meta.category}\n**Tags:** ${meta.tags?.join(", ")}\n\nSubmitted via \`sweny publish\`.`
+            : `## New Skill: ${id}\n\nSubmitted via \`sweny publish\`.`;
+        const prResult = execSync(`gh pr create --repo swenyai/marketplace --head ${username}:${branchName} --title "feat: add ${type} ${id}" --body "${prBody.replace(/"/g, '\\"')}"`, { stdio: "pipe", encoding: "utf-8" });
+        const prUrl = prResult.trim();
+        // Cleanup temp dir
+        fs.rmSync(tmpDir, { recursive: true, force: true });
+        s.stop(`PR created: ${chalk.cyan(prUrl)}`);
+        return { type, id, name: id, prUrl };
+    }
+    catch (e) {
+        s.stop("Failed to create PR");
+        p.log.error(`GitHub error: ${e instanceof Error ? e.message : e}`);
+        p.log.info("Falling back to save locally...");
+        return await saveLocally(type, id, sourcePath);
+    }
+}
+async function saveLocally(type, id, sourcePath) {
+    const outputDir = path.resolve("sweny-publish");
+    fs.mkdirSync(outputDir, { recursive: true });
+    if (type === "workflow") {
+        const dest = path.join(outputDir, `${id}.yml`);
+        fs.copyFileSync(sourcePath, dest);
+        p.log.success(`Saved to ${chalk.cyan(dest)}`);
+        p.log.info(`Submit manually: copy to workflows/community/ in a fork of swenyai/marketplace`);
+        return { type, id, name: id, outputPath: dest };
+    }
+    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));
+        }
+        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 };
+    }
+}
+// ── Command registration ───────────────────────────────────────────────
+export function registerPublishCommand(program) {
+    program
+        .command("publish")
+        .description("Publish a workflow or skill to the SWEny Marketplace")
+        .action(async () => {
+        await runPublish();
+    });
+}