@sweny-ai/core 0.1.51 → 0.1.53

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();
+    });
+}

package/dist/cli/templates.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Starter workflow templates offered during `sweny new`.
+ *
+ * Each template is a valid SWEny workflow YAML. Templates are self-contained
+ * strings — no filesystem reads needed, works from npm install.
+ */
+export interface WorkflowTemplate {
+    id: string;
+    name: string;
+    description: string;
+    yaml: string;
+}
+export declare const WORKFLOW_TEMPLATES: WorkflowTemplate[];

package/dist/cli/templates.js

@@ -0,0 +1,181 @@
+/**
+ * Starter workflow templates offered during `sweny new`.
+ *
+ * Each template is a valid SWEny workflow YAML. Templates are self-contained
+ * strings — no filesystem reads needed, works from npm install.
+ */
+export const WORKFLOW_TEMPLATES = [
+    {
+        id: "pr-review",
+        name: "PR Review Bot",
+        description: "Automated code review on pull requests",
+        yaml: `id: pr-review
+name: PR Review Bot
+description: Review pull requests for code quality, security issues, and best practices.
+entry: fetch-diff
+
+nodes:
+  fetch-diff:
+    name: Fetch PR Changes
+    instruction: |
+      Fetch the pull request diff. Identify which files changed,
+      what was added, modified, or removed. Summarize the scope
+      of the change.
+    skills: [github]
+
+  review-code:
+    name: Review Code
+    instruction: |
+      Review the code changes for:
+      - Security vulnerabilities (injection, auth issues, secrets)
+      - Logic errors and edge cases
+      - Code style and readability
+      - Test coverage gaps
+
+      Be specific — reference file names and line numbers.
+      Categorize findings as critical, important, or minor.
+    skills: [github]
+
+  post-review:
+    name: Post Review Comment
+    instruction: |
+      Post a structured review comment on the pull request.
+      Lead with a summary, then list findings by severity.
+      If no issues found, approve with a brief note.
+    skills: [github]
+
+edges:
+  - from: fetch-diff
+    to: review-code
+  - from: review-code
+    to: post-review
+`,
+    },
+    {
+        id: "issue-triage",
+        name: "Issue Triage",
+        description: "Classify, prioritize, and label incoming issues",
+        yaml: `id: issue-triage
+name: Issue Triage
+description: Automatically classify, prioritize, and label new issues.
+entry: classify
+
+nodes:
+  classify:
+    name: Classify Issue
+    instruction: |
+      Read the issue title and body. Classify it as one of:
+      - bug: Something is broken
+      - feature: A new capability request
+      - question: Asking for help or clarification
+      - chore: Maintenance, refactoring, docs
+
+      Also assess priority:
+      - P0: Production is down or data loss
+      - P1: Major feature broken, workaround exists
+      - P2: Minor issue, low impact
+      - P3: Nice to have, no urgency
+    skills: [github]
+
+  label-and-assign:
+    name: Apply Labels
+    instruction: |
+      Based on the classification, apply the appropriate labels
+      to the issue (e.g. "bug", "P1", "needs-triage").
+      Add a comment explaining the classification rationale.
+    skills: [github]
+
+edges:
+  - from: classify
+    to: label-and-assign
+`,
+    },
+    {
+        id: "security-scan",
+        name: "Security Audit",
+        description: "Scan code and dependencies for security issues",
+        yaml: `id: security-scan
+name: Security Audit
+description: Scan repository code and dependencies for security vulnerabilities.
+entry: scan-code
+
+nodes:
+  scan-code:
+    name: Scan Code for Secrets
+    instruction: |
+      Search the repository for exposed secrets, API keys,
+      passwords, and tokens in code, config files, and
+      environment templates. Check for common patterns:
+      hardcoded credentials, leaked keys, insecure defaults.
+    skills: [github]
+
+  scan-deps:
+    name: Scan Dependencies
+    instruction: |
+      Review dependency manifests (package.json, requirements.txt,
+      go.mod, etc.) for known vulnerable versions. Check for
+      outdated packages with security advisories.
+    skills: [github]
+
+  compile-report:
+    name: Compile Security Report
+    instruction: |
+      Compile findings from the code and dependency scans into
+      a structured security report. Categorize by severity
+      (critical, high, medium, low). Include remediation steps
+      for each finding.
+    skills: [github]
+
+edges:
+  - from: scan-code
+    to: scan-deps
+  - from: scan-deps
+    to: compile-report
+`,
+    },
+    {
+        id: "release-notes",
+        name: "Release Notes",
+        description: "Generate release notes from commits and PRs",
+        yaml: `id: release-notes
+name: Release Notes Generator
+description: Generate structured release notes from recent commits and merged PRs.
+entry: gather
+
+nodes:
+  gather:
+    name: Gather Changes
+    instruction: |
+      List all commits and merged pull requests since the last
+      release tag. For each, extract: title, author, PR number,
+      and a brief description of what changed.
+    skills: [github]
+
+  categorize:
+    name: Categorize Changes
+    instruction: |
+      Group the changes into categories:
+      - Features: New capabilities
+      - Fixes: Bug fixes
+      - Improvements: Performance, refactoring, DX
+      - Breaking Changes: Anything that requires migration
+
+      Flag any breaking changes prominently.
+    skills: [github]
+
+  write-notes:
+    name: Write Release Notes
+    instruction: |
+      Write polished release notes in markdown. Lead with
+      highlights, then list changes by category. Credit
+      contributors. Keep it concise but informative.
+    skills: [github]
+
+edges:
+  - from: gather
+    to: categorize
+  - from: categorize
+    to: write-notes
+`,
+    },
+];